root/src/xdisp.c

DEFINITIONS

1. it_char_has_category
2. char_can_wrap_before
3. char_can_wrap_after
4. fill_column_indicator_column
5. redisplay_other_windows
6. wset_redisplay
7. fset_redisplay
8. bset_redisplay
9. bset_update_mode_line
10. wset_update_mode_line
11. ATTRIBUTE_FORMAT_PRINTF
12. ATTRIBUTE_FORMAT_PRINTF
13. window_text_bottom_y
14. window_box_width
15. window_box_height
16. window_box_left_offset
17. window_box_right_offset
18. window_box_left
19. window_box_right
20. window_box
21. window_box_edges
22. line_bottom_y
23. DEFUN
24. default_line_pixel_height
25. string_from_display_spec
26. window_hscroll_limited
27. reset_box_start_end_flags
28. pos_visible_p
29. check_char_and_length
30. string_pos_nchars_ahead
31. string_pos
32. c_string_pos
33. number_of_chars
34. compute_string_pos
35. estimate_mode_line_height
36. pixel_to_glyph_coords
37. x_y_to_hpos_vpos
38. frame_to_window_pixel_xy
39. get_glyph_string_clip_rects
40. get_glyph_string_clip_rect
41. get_phys_cursor_geometry
42. remember_mouse_glyph
43. adjust_window_ends
44. hscrolling_current_line_p
45. safe_eval_handler
46. safe__call
47. safe_call
48. safe_call1
49. safe__call1
50. safe_eval
51. safe__eval
52. safe_call2
53. CHECK_IT
54. CHECK_WINDOW_END
55. init_iterator
56. get_narrowed_width
57. get_narrowed_len
58. get_medium_narrowing_begv
59. get_medium_narrowing_zv
60. get_nearby_bol_pos
61. get_small_narrowing_begv
62. get_large_narrowing_begv
63. get_large_narrowing_zv
64. unwind_narrowed_begv
65. start_display
66. in_ellipses_for_invisible_text_p
67. init_from_display_pos
68. init_to_row_start
69. init_to_row_end
70. handle_stop
71. compute_stop_pos
72. compute_display_string_pos
73. compute_display_string_end
74. handle_fontified_prop
75. face_at_pos
76. handle_face_prop
77. underlying_face_id
78. face_before_or_after_it_pos
79. handle_invisible_prop
80. setup_for_ellipsis
81. find_display_property
82. get_display_property
83. display_min_width
84. handle_display_prop
85. handle_display_spec
86. display_prop_end
87. handle_single_display_spec
88. display_prop_intangible_p
89. single_display_spec_string_p
90. display_prop_string_p
91. string_buffer_position_lim
92. string_buffer_position
93. handle_composition_prop
94. handle_overlay_change
95. next_overlay_string
96. compare_overlay_entries
97. load_overlay_strings
98. get_overlay_strings_1
99. get_overlay_strings
100. push_it
101. iterate_out_of_display_property
102. restore_face_box_flags
103. pop_it
104. back_to_previous_line_start
105. strings_with_newlines
106. forward_to_next_line_start
107. back_to_previous_visible_line_start
108. reseat_at_previous_visible_line_start
109. reseat_at_next_visible_line_start
110. reseat
111. reseat_1
112. reseat_to_string
113. lookup_glyphless_char_display
114. merge_escape_glyph_face
115. merge_glyphless_glyph_face
116. forget_escape_and_glyphless_faces
117. get_next_display_element
118. set_iterator_to_next
119. next_element_from_display_vector
120. get_visually_first_element
121. next_element_from_string
122. next_element_from_c_string
123. next_element_from_ellipsis
124. next_element_from_image
125. next_element_from_xwidget
126. next_element_from_stretch
127. compute_stop_pos_backwards
128. handle_stop_backwards
129. next_element_from_buffer
130. next_element_from_composition
131. move_it_in_display_line_to
132. move_it_in_display_line
133. move_it_to
134. move_it_vertically_backward
135. move_it_vertically
136. move_it_past_eol
137. move_it_by_lines
138. partial_line_height
139. fast_move_it_horizontally
140. in_display_vector_p
141. window_text_pixel_size
142. DEFUN
143. format_nargs
144. add_to_log
145. vadd_to_log
146. message_log_maybe_newline
147. message_dolog
148. message_log_check_duplicate
149. message3
150. message_to_stderr
151. message3_nolog
152. message1
153. message1_nolog
154. message_with_string
155. ATTRIBUTE_FORMAT_PRINTF
156. message
157. update_echo_area
158. ensure_echo_area_buffers
159. with_echo_area_buffer
160. with_echo_area_buffer_unwind_data
161. unwind_with_echo_area_buffer
162. setup_echo_area_for_printing
163. display_echo_area
164. display_echo_area_1
165. resize_echo_area_exactly
166. resize_mini_window_1
167. resize_mini_window
168. current_message
169. current_message_1
170. push_message
171. restore_message
172. pop_message_unwind
173. check_message_stack
174. clear_message_stack
175. truncate_echo_area
176. truncate_message_1
177. set_message
178. set_message_1
179. clear_message
180. clear_garbaged_frames
181. echo_area_display
182. window_buffer_changed
183. mode_line_update_needed
184. window_frozen_p
185. format_mode_line_unwind_data
186. unwind_format_mode_line
187. store_mode_line_noprop_char
188. store_mode_line_noprop
189. gui_consider_frame_title
190. needs_no_redisplay
191. prepare_menu_bars
192. update_menu_bar
193. restore_selected_window
194. restore_frame_selected_window
195. update_tab_bar
196. display_tab_bar
197. build_desired_tab_bar_string
198. display_tab_bar_line
199. tab_bar_height
200. redisplay_tab_bar
201. tab_bar_item_info
202. get_tab_bar_item
203. get_tab_bar_item_kbd
204. handle_tab_bar_click
205. note_tab_bar_highlight
206. tty_get_tab_bar_item
207. tty_handle_tab_bar_click
208. update_tool_bar
209. build_desired_tool_bar_string
210. display_tool_bar_line
211. tool_bar_height
212. redisplay_tool_bar
213. tool_bar_item_info
214. get_tool_bar_item
215. handle_tool_bar_click_with_device
216. handle_tool_bar_click
217. note_tool_bar_highlight
218. hscroll_window_tree
219. hscroll_windows
220. debug_method_add
221. text_outside_line_unchanged_p
222. redisplay
223. overlay_arrow_string_or_property
224. overlay_arrow_in_current_buffer_p
225. overlay_arrows_changed_p
226. update_overlay_arrows
227. overlay_arrow_at_row
228. check_point_in_composition
229. reconsider_clip_changes
230. propagate_buffer_redisplay
231. redisplay_internal
232. unwind_redisplay_preserve_echo_area
233. redisplay_preserve_echo_area
234. unwind_redisplay
235. unwind_display_working_on_window
236. mark_window_display_accurate_1
237. mark_window_display_accurate
238. disp_char_vector
239. block_buffer_flips
240. unblock_buffer_flips
241. buffer_flipping_blocked_p
242. redisplay_windows
243. redisplay_window_error
244. redisplay_window_0
245. redisplay_window_1
246. update_redisplay_ticks
247. set_cursor_from_row
248. run_window_scroll_functions
249. cursor_row_fully_visible_p
250. try_scrolling
251. compute_window_start_on_continuation_line
252. try_cursor_movement
253. set_vertical_scroll_bar
254. set_horizontal_scroll_bar
255. window_start_acceptable_p
256. DEFUN
257. redisplay_window
258. try_window
259. try_window_reusing_current_matrix
260. find_last_row_displaying_text
261. find_last_unchanged_at_beg_row
262. find_first_unchanged_at_end_row
263. sync_frame_with_window_matrix_rows
264. row_containing_pos
265. try_window_id
266. dump_glyph_row
267. dump_glyph
268. dump_glyph_row
269. DEFUN
270. DEFUN
271. DEFUN
272. get_overlay_arrow_glyph_row
273. insert_left_trunc_glyphs
274. row_hash
275. compute_line_metrics
276. clear_position
277. append_space_for_newline
278. extend_face_to_end_of_line
279. trailing_whitespace_p
280. highlight_trailing_whitespace
281. row_for_charpos_p
282. cursor_row_p
283. push_prefix_prop
284. get_it_property
285. get_line_prefix_it_property
286. handle_line_prefix
287. unproduce_glyphs
288. find_row_edges
289. display_count_lines_logically
290. display_count_lines_visually
291. maybe_produce_line_number
292. should_produce_line_number
293. row_text_area_empty
294. display_line
295. DEFUN
296. DEFUN
297. DEFUN
298. display_menu_bar
299. deep_copy_glyph_row
300. display_tty_menu_item
301. redisplay_mode_lines
302. display_mode_lines
303. display_mode_line
304. move_elt_to_front
305. safe_set_text_properties
306. display_mode_element
307. store_mode_line_string
308. pint2str
309. pint2hrstr
310. decode_mode_spec_coding
311. percent99
312. decode_mode_spec
313. count_lines
314. display_count_lines
315. display_string
316. invisible_prop
317. DEFUN
318. calc_pixel_width_or_height
319. get_font_ascent_descent
320. dump_glyph_string
321. init_glyph_string
322. append_glyph_string_lists
323. prepend_glyph_string_lists
324. append_glyph_string
325. get_char_face_and_encoding
326. get_glyph_face_and_encoding
327. get_char_glyph_code
328. fill_composite_glyph_string
329. fill_gstring_glyph_string
330. fill_glyphless_glyph_string
331. fill_glyph_string
332. fill_image_glyph_string
333. fill_xwidget_glyph_string
334. fill_stretch_glyph_string
335. get_per_char_metric
336. normal_char_ascent_descent
337. normal_char_height
338. gui_get_glyph_overhangs
339. left_overwritten
340. left_overwriting
341. right_overwritten
342. right_overwriting
343. set_glyph_string_background_width
344. glyph_string_containing_background_width
345. compute_overhangs_and_x
346. draw_glyphs
347. font_for_underline_metrics
348. append_glyph
349. append_composite_glyph
350. take_vertical_position_into_account
351. produce_image_glyph
352. produce_xwidget_glyph
353. append_stretch_glyph
354. produce_stretch_glyph
355. produce_special_glyphs
356. pad_mode_line
357. calc_line_height_property
358. append_glyphless_glyph
359. produce_glyphless_glyph
360. gui_produce_glyphs
361. gui_write_glyphs
362. gui_insert_glyphs
363. gui_clear_end_of_line
364. get_specified_cursor_type
365. set_frame_cursor_types
366. get_window_cursor_type
367. notice_overwritten_cursor
368. gui_fix_overlapping_area
369. draw_phys_cursor_glyph
370. erase_phys_cursor
371. display_and_set_cursor
372. update_window_cursor
373. update_cursor_in_window_tree
374. gui_update_cursor
375. gui_clear_cursor
376. draw_row_with_mouse_face
377. show_mouse_face
378. clear_mouse_face
379. coords_in_mouse_face_p
380. cursor_in_mouse_face_p
381. rows_from_pos_range
382. mouse_face_from_buffer_pos
383. fast_find_string_pos
384. mouse_face_from_string_pos
385. on_hot_spot_p
386. find_hot_spot
387. define_frame_cursor1
388. note_mode_line_or_margin_highlight
389. note_mouse_highlight
390. gui_clear_window_mouse_face
391. cancel_mouse_face
392. expose_area
393. expose_line
394. expose_overlaps
395. phys_cursor_in_rect_p
396. gui_draw_vertical_border
397. gui_draw_right_divider
398. gui_draw_bottom_divider
399. expose_window
400. expose_window_tree
401. expose_frame
402. gui_intersect_rectangles
403. gui_union_rectangles
404. syms_of_xdisp
405. init_xdisp
406. show_hourglass
407. start_hourglass
408. cancel_hourglass
409. adjust_glyph_width_for_mouse_face
410. get_cursor_offset_for_mouse_face

     1 /* Display generation from window structure and buffer text.
     2 
     3 Copyright (C) 1985-2023 Free Software Foundation, Inc.
     4 
     5 This file is part of GNU Emacs.
     6 
     7 GNU Emacs is free software: you can redistribute it and/or modify
     8 it under the terms of the GNU General Public License as published by
     9 the Free Software Foundation, either version 3 of the License, or (at
    10 your option) any later version.
    11 
    12 GNU Emacs is distributed in the hope that it will be useful,
    13 but WITHOUT ANY WARRANTY; without even the implied warranty of
    14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    15 GNU General Public License for more details.
    16 
    17 You should have received a copy of the GNU General Public License
    18 along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
    19 
    20 /* New redisplay written by Gerd Moellmann <gerd@gnu.org>.
    21 
    22    Redisplay.
    23 
    24    Emacs separates the task of updating the display from code
    25    modifying global state, e.g. buffer text.  This way functions
    26    operating on buffers don't also have to be concerned with updating
    27    the display.
    28 
    29    Updating the display is triggered by the Lisp interpreter when it
    30    decides it's time to do it.  This is done either automatically for
    31    you as part of the interpreter's command loop or as the result of
    32    calling Lisp functions like `sit-for'.  The C function
    33    `redisplay_internal' in xdisp.c is the only entry into the inner
    34    redisplay code.
    35 
    36    The following diagram shows how redisplay code is invoked.  As you
    37    can see, Lisp calls redisplay and vice versa.
    38 
    39    Under window systems like X, some portions of the redisplay code
    40    are also called asynchronously, due to mouse movement or expose
    41    events.  "Asynchronously" in this context means that any C function
    42    which calls maybe_quit or process_pending_signals could enter
    43    redisplay via expose_frame and/or note_mouse_highlight, if X events
    44    were recently reported to Emacs about mouse movements or frame(s)
    45    that were exposed.  And such redisplay could invoke the Lisp
    46    interpreter, e.g. via the :eval forms in mode-line-format, and as
    47    result the global state could change.  It is therefore very
    48    important that C functions which might cause such "asynchronous"
    49    redisplay, but cannot tolerate the results, use
    50    block_input/unblock_input around code fragments which assume that
    51    global Lisp state doesn't change.  If you don't follow this rule,
    52    you will encounter bugs which are very hard to explain.  One place
    53    that needs to take such precautions is timer_check, some of whose
    54    code cannot tolerate changes in timer alists while it processes
    55    timers.
    56 
    57    +--------------+   redisplay     +----------------+
    58    | Lisp machine |---------------->| Redisplay code |<--+
    59    +--------------+   (xdisp.c)     +----------------+   |
    60           ^                                  |           |
    61           +----------------------------------+           |
    62             Block input to prevent this when             |
    63             called asynchronously!                       |
    64                                                          |
    65                     note_mouse_highlight (asynchronous)  |
    66                                                          |
    67                                     X mouse events  -----+
    68                                                          |
    69                             expose_frame (asynchronous)  |
    70                                                          |
    71                                    X expose events  -----+
    72 
    73    What does redisplay do?  Obviously, it has to figure out somehow what
    74    has been changed since the last time the display has been updated,
    75    and to make these changes visible.  Preferably it would do that in
    76    a moderately intelligent way, i.e. fast.
    77 
    78    Changes in buffer text can be deduced from window and buffer
    79    structures, and from some global variables like `beg_unchanged' and
    80    `end_unchanged'.  The contents of the display are additionally
    81    recorded in a `glyph matrix', a two-dimensional matrix of glyph
    82    structures.  Each row in such a matrix corresponds to a line on the
    83    display, and each glyph in a row corresponds to a column displaying
    84    a character, an image, or what else.  This matrix is called the
    85    `current glyph matrix' or `current matrix' in redisplay
    86    terminology.
    87 
    88    For buffer parts that have been changed since the last update, a
    89    second glyph matrix is constructed, the so called `desired glyph
    90    matrix' or short `desired matrix'.  Current and desired matrix are
    91    then compared to find a cheap way to update the display, e.g. by
    92    reusing part of the display by scrolling lines.  The actual update
    93    of the display of each window by comparing the desired and the
    94    current matrix is done by `update_window', which calls functions
    95    which draw to the glass (those functions are specific to the type
    96    of the window's frame: X, w32, NS, etc.).
    97 
    98    Once the display of a window on the glass has been updated, its
    99    desired matrix is used to update the corresponding rows of the
   100    current matrix, and then the desired matrix is discarded.
   101 
   102    You will find a lot of redisplay optimizations when you start
   103    looking at the innards of redisplay.  The overall goal of all these
   104    optimizations is to make redisplay fast because it is done
   105    frequently.  Some of these optimizations are implemented by the
   106    following functions:
   107 
   108     . try_cursor_movement
   109 
   110       This function tries to update the display if the text in the
   111       window did not change and did not scroll, only point moved, and
   112       it did not move off the displayed portion of the text.
   113 
   114     . try_window_reusing_current_matrix
   115 
   116       This function reuses the current matrix of a window when text
   117       has not changed, but the window start changed (e.g., due to
   118       scrolling).
   119 
   120     . try_window_id
   121 
   122       This function attempts to redisplay a window by reusing parts of
   123       its existing display.  It finds and reuses the part that was not
   124       changed, and redraws the rest.  (The "id" part in the function's
   125       name stands for "insert/delete", not for "identification" or
   126       somesuch.)
   127 
   128     . try_window
   129 
   130       This function performs the full, unoptimized, redisplay of a
   131       single window assuming that its fonts were not changed and that
   132       the cursor will not end up in the scroll margins.  (Loading
   133       fonts requires re-adjustment of dimensions of glyph matrices,
   134       which makes this method impossible to use.)
   135 
   136    The optimizations are tried in sequence (some can be skipped if
   137    it is known that they are not applicable).  If none of the
   138    optimizations were successful, redisplay calls redisplay_windows,
   139    which performs a full redisplay of all windows.
   140 
   141    Note that there's one more important optimization up Emacs's
   142    sleeve, but it is related to actually redrawing the potentially
   143    changed portions of the window/frame, not to reproducing the
   144    desired matrices of those potentially changed portions.  Namely,
   145    the function update_frame and its subroutines, which you will find
   146    in dispnew.c, compare the desired matrices with the current
   147    matrices, and only redraw the portions that changed.  So it could
   148    happen that the functions in this file for some reason decide that
   149    the entire desired matrix needs to be regenerated from scratch, and
   150    still only parts of the Emacs display, or even nothing at all, will
   151    be actually delivered to the glass, because update_frame has found
   152    that the new and the old screen contents are similar or identical.
   153 
   154    Desired matrices.
   155 
   156    Desired matrices are always built per Emacs window.  It is
   157    important to know that a desired matrix is in general "sparse": it
   158    only has some of the glyph rows "enabled".  This is because
   159    redisplay tries to optimize its work, and thus only generates
   160    glyphs for rows that need to be updated on the screen.  Rows that
   161    don't need to be updated are left "disabled", and their contents
   162    should be ignored.
   163 
   164    The function `display_line' is the central function to look at if
   165    you are interested in how the rows of the desired matrix are
   166    produced.  It constructs one row in a desired matrix given an
   167    iterator structure containing both a buffer position and a
   168    description of the environment in which the text is to be
   169    displayed.  But this is too early, read on.
   170 
   171    Glyph rows.
   172 
   173    A glyph row is an array of `struct glyph', where each glyph element
   174    describes a "display element" to be shown on the screen.  More
   175    accurately, a glyph row can have up to 3 different arrays of
   176    glyphs: one each for every display margins, and one for the "text
   177    area", where buffer text is displayed.  The text-area glyph array
   178    is always present, whereas the arrays for the marginal areas are
   179    present (non-empty) only if the corresponding display margin is
   180    shown in the window.  If the glyph array for a marginal area is not
   181    present its beginning and end coincide, i.e. such arrays are
   182    actually empty (they contain no glyphs).  Frame glyph matrices, used
   183    on text-mode terminals (see below) never have marginal areas; they
   184    treat the entire frame-wide row of glyphs as a single large "text
   185    area".
   186 
   187    Iteration over buffer and strings.
   188 
   189    Characters and pixmaps displayed for a range of buffer text depend
   190    on various settings of buffers and windows, on overlays and text
   191    properties, on display tables, on selective display.  The good news
   192    is that all this hairy stuff is hidden behind a small set of
   193    interface functions taking an iterator structure (`struct it')
   194    argument.
   195 
   196    Iteration over things to be displayed is then simple.  It is
   197    started by initializing an iterator with a call to `init_iterator',
   198    passing it the buffer position where to start iteration.  For
   199    iteration over strings, pass -1 as the position to `init_iterator',
   200    and call `reseat_to_string' when the string is ready, to initialize
   201    the iterator for that string.  Thereafter, calls to
   202    `get_next_display_element' fill the iterator structure with
   203    relevant information about the next thing to display.  Calls to
   204    `set_iterator_to_next' move the iterator to the next thing.
   205 
   206    Besides this, an iterator also contains information about the
   207    display environment in which glyphs for display elements are to be
   208    produced.  It has fields for the width and height of the display,
   209    the information whether long lines are truncated or continued, a
   210    current X and Y position, the face currently in effect, and lots of
   211    other stuff you can better see in dispextern.h.
   212 
   213    The "stop position".
   214 
   215    Some of the fields maintained by the iterator change relatively
   216    infrequently.  These include the face of the characters, whether
   217    text is invisible, the object (buffer or display or overlay string)
   218    being iterated, character composition info, etc.  For any given
   219    buffer or string position, the sources of information that affects
   220    the display can be determined by calling the appropriate
   221    primitives, such as `Fnext_single_property_change', but both these
   222    calls and the processing of their return values is relatively
   223    expensive.  To optimize redisplay, the display engine checks these
   224    sources of display information only when needed, not for every
   225    character.  To that end, it always maintains the position of the
   226    next place where it must stop and re-examine all those potential
   227    sources.  This is called "the stop position" and is stored in the
   228    `stop_charpos' field of the iterator.  The stop position is updated
   229    by `compute_stop_pos', which is called whenever the iteration
   230    reaches the current stop position and processes it.  Processing a
   231    stop position is done by `handle_stop', which invokes a series of
   232    handlers, one each for every potential source of display-related
   233    information; see the `it_props' array for those handlers.  For
   234    example, one handler is `handle_face_prop', which detects changes
   235    in face properties, and supplies the face ID that the iterator will
   236    use for all the glyphs it generates up to the next stop position;
   237    this face ID is the result of "realizing" the face specified by the
   238    relevant text properties at this position (see xfaces.c).  Each
   239    handler called by `handle_stop' processes the sources of display
   240    information for which it is "responsible", and returns a value
   241    which tells `handle_stop' what to do next.
   242 
   243    Once `handle_stop' returns, the information it stores in the
   244    iterator fields will not be refreshed until the iteration reaches
   245    the next stop position, which is computed by `compute_stop_pos'
   246    called at the end of `handle_stop'.  `compute_stop_pos' examines
   247    the buffer's or string's interval tree to determine where the text
   248    properties change, finds the next position where overlays and
   249    character composition can change, and stores in `stop_charpos' the
   250    closest position where any of these factors should be reconsidered.
   251 
   252    Handling of the stop position is done as part of the code in
   253    `get_next_display_element'.
   254 
   255    Producing glyphs.
   256 
   257    Glyphs in a desired matrix are normally constructed in a loop
   258    calling `get_next_display_element' and then `PRODUCE_GLYPHS'.  The
   259    call to `PRODUCE_GLYPHS' will fill the iterator structure with
   260    pixel information about the element being displayed and at the same
   261    time will produce glyphs for it.  If the display element fits on
   262    the line being displayed, `set_iterator_to_next' is called next,
   263    otherwise the glyphs produced are discarded, and `display_line'
   264    marks this glyph row as a "continued line".  The function
   265    `display_line' is the workhorse of filling glyph rows in the
   266    desired matrix with glyphs.  In addition to producing glyphs, it
   267    also handles line truncation and continuation, word wrap, and
   268    cursor positioning (for the latter, see `set_cursor_from_row').
   269 
   270    Frame matrices.
   271 
   272    That just couldn't be all, could it?  What about terminal types not
   273    supporting operations on sub-windows of the screen (a.k.a. "TTY" or
   274    "text-mode terminals")?  To update the display on such a terminal,
   275    window-based glyph matrices are not well suited.  To be able to
   276    reuse part of the display (scrolling lines up and down), we must
   277    instead have a view of the whole screen.  This is what `frame
   278    matrices' are for.  They are a trick.
   279 
   280    Frames on text terminals have a glyph pool.  Windows on such a
   281    frame sub-allocate their glyph memory from their frame's glyph
   282    pool.  The frame itself is given its own glyph matrices.  By
   283    coincidence---or maybe something else---rows in window glyph
   284    matrices are slices of corresponding rows in frame matrices.  Thus
   285    writing to window matrices implicitly updates a frame matrix which
   286    provides us with the view of the whole screen that we originally
   287    wanted to have without having to move many bytes around.  Then
   288    updating all the visible windows on text-terminal frames is done by
   289    using the frame matrices, which allows frame-global optimization of
   290    what is actually written to the glass.
   291 
   292    Frame matrices don't have marginal areas, only a text area.  That
   293    is, the entire row of glyphs that spans the width of a text-mode
   294    frame is treated as a single large "text area" for the purposes of
   295    manipulating and updating a frame glyph matrix.
   296 
   297    To be honest, there is a little bit more done for frame matrices,
   298    but not much more.  If you plan to extend that code, take a look at
   299    dispnew.c.  The function build_frame_matrix is a good starting
   300    point.
   301 
   302    Simulating display.
   303 
   304    Some of Emacs commands and functions need to take display layout
   305    into consideration.  For example, C-n moves to the next screen
   306    line, but to implement that, Emacs needs to find the buffer
   307    position which is directly below the cursor position on display.
   308    This is not trivial when buffer display includes variable-size
   309    elements such as different fonts, tall images, etc.
   310 
   311    To solve this problem, the display engine implements several
   312    functions that can move through buffer text in the same manner as
   313    `display_line' and `display_string' do, but without producing any
   314    glyphs for the glyph matrices.  The workhorse of this is
   315    `move_it_in_display_line_to'.  Its code and logic are very similar
   316    to `display_line', but it differs in two important aspects: it
   317    doesn't produce glyphs for any glyph matrix, and it returns a
   318    status telling the caller how it ended the iteration: whether it
   319    reached the required position, hit the end of line, arrived at the
   320    window edge without exhausting the buffer's line, etc.  Since the
   321    glyphs are not produced, the layout information available to the
   322    callers of this function is what is recorded in `struct it' by the
   323    iteration process.
   324 
   325    Several higher-level functions call `move_it_in_display_line_to' to
   326    perform more complex tasks: `move_it_by_lines' can move N lines up
   327    or down from a given buffer position and `move_it_to' can move to a
   328    given buffer position or to a given X or Y pixel coordinate.
   329 
   330    These functions are called by the display engine itself as well,
   331    when it needs to make layout decisions before producing the glyphs.
   332    For example, one of the first things to decide when redisplaying a
   333    window is where to put the `window-start' position; if the window
   334    is to be recentered (the default), Emacs makes that decision by
   335    starting from the position of point, then moving up the number of
   336    lines corresponding to half the window height using
   337    `move_it_by_lines'.
   338 
   339    Bidirectional display.
   340 
   341    Bidirectional display adds quite some hair to this already complex
   342    design.  The good news are that a large portion of that hairy stuff
   343    is hidden in bidi.c behind only 3 interfaces.  bidi.c implements a
   344    reordering engine which is called by `set_iterator_to_next' and
   345    returns the next character to display in the visual order.  See
   346    commentary on bidi.c for more details.  As far as redisplay is
   347    concerned, the effect of calling `bidi_move_to_visually_next', the
   348    main interface of the reordering engine, is that the iterator gets
   349    magically placed on the buffer or string position that is to be
   350    displayed next in the visual order.  In other words, a linear
   351    iteration through the buffer/string is replaced with a non-linear
   352    one.  All the rest of the redisplay is oblivious to the bidi
   353    reordering.
   354 
   355    Well, almost oblivious---there are still complications, most of
   356    them due to the fact that buffer and string positions no longer
   357    change monotonously with glyph indices in a glyph row.  Moreover,
   358    for continued lines, the buffer positions may not even be
   359    monotonously changing with vertical positions.  Also, accounting
   360    for face changes, overlays, etc. becomes more complex because
   361    non-linear iteration could potentially skip many positions with
   362    such changes, and then cross them again on the way back (see
   363    `handle_stop_backwards')...
   364 
   365    One other prominent effect of bidirectional display is that some
   366    paragraphs of text need to be displayed starting at the right
   367    margin of the window---the so-called right-to-left, or R2L
   368    paragraphs.  R2L paragraphs are displayed with R2L glyph rows,
   369    which have their `reversed_p' flag set.  The bidi reordering engine
   370    produces characters in such rows starting from the character which
   371    should be the rightmost on display.  `PRODUCE_GLYPHS' then reverses
   372    the order, when it fills up the glyph row whose `reversed_p' flag
   373    is set, by prepending each new glyph to what is already there,
   374    instead of appending it.  When the glyph row is complete, the
   375    function `extend_face_to_end_of_line' fills the empty space to the
   376    left of the leftmost character with special glyphs, which will
   377    display as, well, empty.  On text terminals, these special glyphs
   378    are simply blank characters.  On graphics terminals, there's a
   379    single stretch glyph of a suitably computed width.  Both the blanks
   380    and the stretch glyph are given the face of the background of the
   381    line.  This way, the terminal-specific back-end can still draw the
   382    glyphs left to right, even for R2L lines.
   383 
   384    Bidirectional display and character compositions.
   385 
   386    Some scripts cannot be displayed by drawing each character
   387    individually, because adjacent characters change each other's shape
   388    on display.  For example, Arabic and Indic scripts belong to this
   389    category.
   390 
   391    Emacs display supports this by providing "character compositions",
   392    most of which is implemented in composite.c.  During the buffer
   393    scan that delivers characters to `PRODUCE_GLYPHS', if the next
   394    character to be delivered is a composed character, the iteration
   395    calls `composition_reseat_it' and `next_element_from_composition'.
   396    If they succeed to compose the character with one or more of the
   397    following characters, the whole sequence of characters that were
   398    composed is recorded in the `struct composition_it' object that is
   399    part of the buffer iterator.  The composed sequence could produce
   400    one or more font glyphs (called "grapheme clusters") on the screen.
   401    Each of these grapheme clusters is then delivered to
   402    `PRODUCE_GLYPHS' in the direction corresponding to the current bidi
   403    scan direction (recorded in the `scan_dir' member of the `struct
   404    bidi_it' object that is part of the iterator).  In particular, if
   405    the bidi iterator currently scans the buffer backwards, the
   406    grapheme clusters are delivered back to front.  This reorders the
   407    grapheme clusters as appropriate for the current bidi context.
   408    Note that this means that the grapheme clusters are always stored
   409    in the `LGSTRING' object (see composite.c) in the logical order.
   410 
   411    Moving an iterator in bidirectional text
   412    without producing glyphs.
   413 
   414    Note one important detail mentioned above: that the bidi reordering
   415    engine, driven by the iterator, produces characters in R2L rows
   416    starting at the character that will be the rightmost on display.
   417    As far as the iterator is concerned, the geometry of such rows is
   418    still left to right, i.e. the iterator "thinks" the first character
   419    is at the leftmost pixel position.  The iterator does not know that
   420    `PRODUCE_GLYPHS' reverses the order of the glyphs that the iterator
   421    delivers.  This is important when functions from the `move_it_*'
   422    family are used to get to certain screen position or to match
   423    screen coordinates with buffer coordinates: these functions use the
   424    iterator geometry, which is left to right even in R2L paragraphs.
   425    This works well with most callers of `move_it_*', because they need
   426    to get to a specific column, and columns are still numbered in the
   427    reading order, i.e. the rightmost character in a R2L paragraph is
   428    still column zero.  But some callers do not get well with this; a
   429    notable example is mouse clicks that need to find the character
   430    that corresponds to certain pixel coordinates.  See
   431    `buffer_posn_from_coords' in dispnew.c for how this is handled.  */
   432 
   433 #include <config.h>
   434 #include <stdlib.h>
   435 #include <limits.h>
   436 #include <math.h>
   437 
   438 #include "lisp.h"
   439 #include "atimer.h"
   440 #include "composite.h"
   441 #include "keyboard.h"
   442 #include "sysstdio.h"
   443 #include "systime.h"
   444 #include "frame.h"
   445 #include "window.h"
   446 #include "termchar.h"
   447 #include "dispextern.h"
   448 #include "character.h"
   449 #include "category.h"
   450 #include "buffer.h"
   451 #include "charset.h"
   452 #include "indent.h"
   453 #include "commands.h"
   454 #include "keymap.h"
   455 #include "disptab.h"
   456 #include "termhooks.h"
   457 #include "termopts.h"
   458 #include "intervals.h"
   459 #include "coding.h"
   460 #include "region-cache.h"
   461 #include "font.h"
   462 #include "fontset.h"
   463 #include "blockinput.h"
   464 #include "xwidget.h"
   465 #ifdef HAVE_WINDOW_SYSTEM
   466 #include TERM_HEADER
   467 #endif /* HAVE_WINDOW_SYSTEM */
   468 
   469 #ifndef FRAME_OUTPUT_DATA
   470 #define FRAME_OUTPUT_DATA(f) (NULL)
   471 #endif
   472 
   473 #define DISP_INFINITY 10000000
   474 
   475 /* Holds the list (error).  */
   476 static Lisp_Object list_of_error;
   477 
   478 #ifdef HAVE_WINDOW_SYSTEM
   479 
   480 /* Test if overflow newline into fringe.  Called with iterator IT
   481    at or past right window margin, and with IT->current_x set.  */
   482 
   483 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(IT)             \
   484   (!NILP (Voverflow_newline_into_fringe)                \
   485    && FRAME_WINDOW_P ((IT)->f)                          \
   486    && ((IT)->bidi_it.paragraph_dir == R2L               \
   487        ? (WINDOW_LEFT_FRINGE_WIDTH ((IT)->w) > 0)       \
   488        : (WINDOW_RIGHT_FRINGE_WIDTH ((IT)->w) > 0))     \
   489    && (IT)->current_x == (IT)->last_visible_x)
   490 
   491 #else /* !HAVE_WINDOW_SYSTEM */
   492 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it) false
   493 #endif /* HAVE_WINDOW_SYSTEM */
   494 
   495 /* Test if the display element loaded in IT, or the underlying buffer
   496    or string character, is a space or a TAB character.  This is used
   497    to determine where word wrapping can occur.  */
   498 
   499 #define IT_DISPLAYING_WHITESPACE(it)                                    \
   500   ((it->what == IT_CHARACTER && (it->c == ' ' || it->c == '\t'))        \
   501    || ((STRINGP (it->string)                                            \
   502         && (SREF (it->string, IT_STRING_BYTEPOS (*it)) == ' '           \
   503             || SREF (it->string, IT_STRING_BYTEPOS (*it)) == '\t'))     \
   504        || (it->s                                                        \
   505            && (it->s[IT_BYTEPOS (*it)] == ' '                           \
   506                || it->s[IT_BYTEPOS (*it)] == '\t'))                     \
   507        || (IT_BYTEPOS (*it) < ZV_BYTE                                   \
   508            && (*BYTE_POS_ADDR (IT_BYTEPOS (*it)) == ' '                 \
   509                || *BYTE_POS_ADDR (IT_BYTEPOS (*it)) == '\t'))))
   510 
   511 /* These are the category sets we use.  They are defined by
   512    kinsoku.el and characters.el.  */
   513 #define NOT_AT_EOL '<'
   514 #define NOT_AT_BOL '>'
   515 #define LINE_BREAKABLE '|'
   516 
   517 static bool
   518 it_char_has_category(struct it *it, int cat)
   519 {
   520   int ch = 0;
   521   if (it->what == IT_CHARACTER)
   522     ch = it->c;
   523   else if (STRINGP (it->string))
   524     ch = SREF (it->string, IT_STRING_BYTEPOS (*it));
   525   else if (it->s)
   526     ch = it->s[IT_BYTEPOS (*it)];
   527   else if (IT_BYTEPOS (*it) < ZV_BYTE)
   528     ch = *BYTE_POS_ADDR (IT_BYTEPOS (*it));
   529 
   530   if (ch == 0)
   531     return false;
   532   else
   533     return CHAR_HAS_CATEGORY (ch, cat);
   534 }
   535 
   536 /* Return true if the current character allows wrapping before it.   */
   537 static bool
   538 char_can_wrap_before (struct it *it)
   539 {
   540   if (!word_wrap_by_category)
   541     return !IT_DISPLAYING_WHITESPACE (it);
   542 
   543   /* For CJK (LTR) text in RTL paragraph, EOL and BOL are flipped.
   544      Because in RTL paragraph, each glyph is prepended to the last
   545      one, effectively drawing right to left.  */
   546   int not_at_bol;
   547   if (it->glyph_row && it->glyph_row->reversed_p)
   548     not_at_bol = NOT_AT_EOL;
   549   else
   550     not_at_bol = NOT_AT_BOL;
   551   /* You cannot wrap before a space or tab because that way you'll
   552      have space and tab at the beginning of next line.  */
   553   return (!IT_DISPLAYING_WHITESPACE (it)
   554           /* Can be at BOL.  */
   555           && !it_char_has_category (it, not_at_bol));
   556 }
   557 
   558 /* Return true if the current character allows wrapping after it.   */
   559 static bool
   560 char_can_wrap_after (struct it *it)
   561 {
   562   if (!word_wrap_by_category)
   563     return IT_DISPLAYING_WHITESPACE (it);
   564 
   565   /* For CJK (LTR) text in RTL paragraph, EOL and BOL are flipped.
   566      Because in RTL paragraph, each glyph is prepended to the last
   567      one, effectively drawing right to left.  */
   568   int not_at_eol;
   569   if (it->glyph_row && it->glyph_row->reversed_p)
   570     not_at_eol = NOT_AT_BOL;
   571   else
   572     not_at_eol = NOT_AT_EOL;
   573 
   574   return (IT_DISPLAYING_WHITESPACE (it)
   575           /* Can break after && can be at EOL.  */
   576           || (it_char_has_category (it, LINE_BREAKABLE)
   577               && !it_char_has_category (it, not_at_eol)));
   578 }
   579 
   580 #undef IT_DISPLAYING_WHITESPACE
   581 #undef NOT_AT_EOL
   582 #undef NOT_AT_BOL
   583 #undef LINE_BREAKABLE
   584 
   585 /* If all the conditions needed to print the fill column indicator are
   586    met, return the (nonnegative) column number, else return a negative
   587    value.  */
   588 static int
   589 fill_column_indicator_column (struct it *it, int char_width)
   590 {
   591   if (display_fill_column_indicator
   592       && !it->w->pseudo_window_p
   593       && it->continuation_lines_width == 0
   594       && CHARACTERP (Vdisplay_fill_column_indicator_character))
   595     {
   596       Lisp_Object col = (EQ (Vdisplay_fill_column_indicator_column, Qt)
   597                          ? BVAR (current_buffer, fill_column)
   598                          : Vdisplay_fill_column_indicator_column);
   599 
   600       /* The stretch width needs to consider the latter
   601          added glyph in append_space_for_newline.  */
   602       if (RANGED_FIXNUMP (0, col, INT_MAX))
   603         {
   604           int icol = XFIXNUM (col);
   605           if (!ckd_mul (&icol, icol, char_width)
   606               && !ckd_add (&icol, icol, it->lnum_pixel_width))
   607             return icol;
   608         }
   609     }
   610   return -1;
   611 }
   612 
   613 /* True means print newline to stdout before next mini-buffer message.  */
   614 
   615 bool noninteractive_need_newline;
   616 
   617 /* True means print newline to message log before next message.  */
   618 
   619 static bool message_log_need_newline;
   620 
   621 /* Three markers that message_dolog uses.
   622    It could allocate them itself, but that causes trouble
   623    in handling memory-full errors.  */
   624 static Lisp_Object message_dolog_marker1;
   625 static Lisp_Object message_dolog_marker2;
   626 static Lisp_Object message_dolog_marker3;
   627 
   628 /* The buffer position of the first character appearing entirely or
   629    partially on the line of the selected window which contains the
   630    cursor; <= 0 if not known.  Set by set_cursor_from_row, used for
   631    redisplay optimization in redisplay_internal.  */
   632 
   633 static struct text_pos this_line_start_pos;
   634 
   635 /* Number of characters past the end of the line above, including the
   636    terminating newline.  */
   637 
   638 static struct text_pos this_line_end_pos;
   639 
   640 /* The vertical positions and the height of this line.  */
   641 
   642 static int this_line_vpos;
   643 static int this_line_y;
   644 static int this_line_pixel_height;
   645 
   646 /* X position at which this display line starts.  Usually zero;
   647    negative if first character is partially visible.  */
   648 
   649 static int this_line_start_x;
   650 
   651 /* The smallest character position seen by move_it_* functions as they
   652    move across display lines.  Used to set MATRIX_ROW_START_CHARPOS of
   653    hscrolled lines, see display_line.  */
   654 
   655 static struct text_pos this_line_min_pos;
   656 
   657 /* Buffer that this_line_.* variables are referring to.  */
   658 
   659 static struct buffer *this_line_buffer;
   660 
   661 /* True if an overlay arrow has been displayed in this window.  */
   662 
   663 static bool overlay_arrow_seen;
   664 
   665 /* Vector containing glyphs for an ellipsis `...'.  */
   666 
   667 static Lisp_Object default_invis_vector[3];
   668 
   669 /* This is the window where the echo area message was displayed.  It
   670    is always a mini-buffer window, but it may not be the same window
   671    currently active as a mini-buffer.  */
   672 
   673 Lisp_Object echo_area_window;
   674 
   675 /* Stack of messages, which are pushed by push_message and popped and
   676    displayed by restore_message.  */
   677 
   678 static Lisp_Object Vmessage_stack;
   679 
   680 /* True means multibyte characters were enabled when the echo area
   681    message was specified.  */
   682 
   683 static bool message_enable_multibyte;
   684 
   685 /* At each redisplay cycle, we should refresh everything there is to refresh.
   686    To do that efficiently, we use many optimizations that try to make sure we
   687    don't waste too much time updating things that haven't changed.
   688    The coarsest such optimization is that, in the most common cases, we only
   689    look at the selected-window.
   690 
   691    To know whether other windows should be considered for redisplay, we use the
   692    variable windows_or_buffers_changed: as long as it is 0, it means that we
   693    have not noticed anything that should require updating anything else than
   694    the selected-window.  If it is set to REDISPLAY_SOME, it means that since
   695    last redisplay, some changes have been made which could impact other
   696    windows.  To know which ones need redisplay, every buffer, window, and frame
   697    has a `redisplay' bit, which (if true) means that this object needs to be
   698    redisplayed.  If windows_or_buffers_changed is 0, we know there's no point
   699    looking for those `redisplay' bits (actually, there might be some such bits
   700    set, but then only on objects which aren't displayed anyway).
   701 
   702    OTOH if it's non-zero we will have to loop through all windows and then
   703    check the `redisplay' bit of the corresponding window, frame, and buffer, in
   704    order to decide whether that window needs attention or not.  Note that we
   705    can't just look at the frame's redisplay bit to decide that the whole frame
   706    can be skipped, since even if the frame's redisplay bit is unset, some of
   707    its windows's redisplay bits may be set.
   708 
   709    Mostly for historical reasons, windows_or_buffers_changed can also take
   710    other non-zero values.  In that case, the precise value doesn't matter (it
   711    encodes the cause of the setting but is only used for debugging purposes),
   712    and what it means is that we shouldn't pay attention to any `redisplay' bits
   713    and we should simply try and redisplay every window out there.  */
   714 
   715 int windows_or_buffers_changed;
   716 
   717 /* Nonzero if we should redraw the mode lines on the next redisplay.
   718    Similarly to `windows_or_buffers_changed', if it has value REDISPLAY_SOME,
   719    then only redisplay the mode lines in those buffers/windows/frames where the
   720    `redisplay' bit has been set.
   721    For any other value, redisplay all mode lines (the number used is then only
   722    used to track down the cause for this full-redisplay).
   723 
   724    Since the frame title uses the same %-constructs as the mode line
   725    (except %c, %C, and %l), if this variable is non-zero, we also consider
   726    redisplaying the title of each frame, see gui_consider_frame_title.
   727 
   728    The `redisplay' bits are the same as those used for
   729    windows_or_buffers_changed, and setting windows_or_buffers_changed also
   730    causes recomputation of the mode lines of all those windows.  IOW this
   731    variable only has an effect if windows_or_buffers_changed is zero, in which
   732    case we should only need to redisplay the mode-line of those objects with
   733    a `redisplay' bit set but not the window's text content (tho we may still
   734    need to refresh the text content of the selected-window).  */
   735 
   736 int update_mode_lines;
   737 
   738 /* True after display_mode_line if %l was used and it displayed a
   739    line number.  */
   740 
   741 static bool line_number_displayed;
   742 
   743 /* Current, index 0, and last displayed echo area message.  Either
   744    buffers from echo_buffers, or nil to indicate no message.  */
   745 
   746 Lisp_Object echo_area_buffer[2];
   747 
   748 /* The buffers referenced from echo_area_buffer.  */
   749 
   750 static Lisp_Object echo_buffer[2];
   751 
   752 /* A vector saved used in with_area_buffer to reduce consing.  */
   753 
   754 static Lisp_Object Vwith_echo_area_save_vector;
   755 
   756 /* True means display_echo_area should display the last echo area
   757    message again.  Set by redisplay_preserve_echo_area.  */
   758 
   759 static bool display_last_displayed_message_p;
   760 
   761 /* True if echo area is being used by print; false if being used by
   762    message.  */
   763 
   764 static bool message_buf_print;
   765 
   766 /* Set to true in clear_message to make redisplay_internal aware
   767    of an emptied echo area.  */
   768 
   769 static bool message_cleared_p;
   770 
   771 /* A scratch glyph row with contents used for generating truncation
   772    glyphs and overlay-arrow glyphs.  */
   773 
   774 #define MAX_SCRATCH_GLYPHS 100
   775 static struct glyph_row scratch_glyph_row;
   776 static struct glyph scratch_glyphs[MAX_SCRATCH_GLYPHS];
   777 
   778 /* Ascent and height of the last line processed by move_it_to.  */
   779 
   780 static int last_height;
   781 
   782 /* True if there's a help-echo in the echo area.  */
   783 
   784 bool help_echo_showing_p;
   785 
   786 /* The maximum distance to look ahead for text properties.  Values
   787    that are too small let us call compute_char_face and similar
   788    functions too often which is expensive.  Values that are too large
   789    let us call compute_char_face and alike too often because we
   790    might not be interested in text properties that far away.  */
   791 
   792 #define TEXT_PROP_DISTANCE_LIMIT 100
   793 
   794 /* SAVE_IT and RESTORE_IT are called when we save a snapshot of the
   795    iterator state and later restore it.  This is needed because the
   796    bidi iterator on bidi.c keeps a stacked cache of its states, which
   797    is really a singleton.  When we use scratch iterator objects to
   798    move around the buffer, we can cause the bidi cache to be pushed or
   799    popped, and therefore we need to restore the cache state when we
   800    return to the original iterator.  */
   801 #define SAVE_IT(ITCOPY, ITORIG, CACHE)          \
   802   do {                                          \
   803     if (CACHE)                                  \
   804       bidi_unshelve_cache (CACHE, true);        \
   805     ITCOPY = ITORIG;                            \
   806     CACHE = bidi_shelve_cache ();               \
   807   } while (false)
   808 
   809 #define RESTORE_IT(pITORIG, pITCOPY, CACHE)     \
   810   do {                                          \
   811     if (pITORIG != pITCOPY)                     \
   812       *(pITORIG) = *(pITCOPY);                  \
   813     bidi_unshelve_cache (CACHE, false);         \
   814     CACHE = NULL;                               \
   815   } while (false)
   816 
   817 /* Functions to mark elements as needing redisplay.  */
   818 enum { REDISPLAY_SOME = 2};     /* Arbitrary choice.  */
   819 
   820 static bool calc_pixel_width_or_height (double *, struct it *, Lisp_Object,
   821                                         struct font *, bool, int *);
   822 
   823 void
   824 redisplay_other_windows (void)
   825 {
   826   if (!windows_or_buffers_changed)
   827     windows_or_buffers_changed = REDISPLAY_SOME;
   828 }
   829 
   830 void
   831 wset_redisplay (struct window *w)
   832 {
   833   /* Beware: selected_window can be nil during early stages.  */
   834   if (!BASE_EQ (make_lisp_ptr (w, Lisp_Vectorlike), selected_window))
   835     redisplay_other_windows ();
   836   w->redisplay = true;
   837 }
   838 
   839 void
   840 fset_redisplay (struct frame *f)
   841 {
   842   redisplay_other_windows ();
   843   f->redisplay = true;
   844 }
   845 
   846 void
   847 bset_redisplay (struct buffer *b)
   848 {
   849   int count = buffer_window_count (b);
   850   if (count > 0)
   851     {
   852       /* ... it's visible in other window than selected,  */
   853       if (count > 1 || b != XBUFFER (XWINDOW (selected_window)->contents))
   854         redisplay_other_windows ();
   855       /* Even if we don't set windows_or_buffers_changed, do set `redisplay'
   856          so that if we later set windows_or_buffers_changed, this buffer will
   857          not be omitted.  */
   858       b->text->redisplay = true;
   859     }
   860 }
   861 
   862 void
   863 bset_update_mode_line (struct buffer *b)
   864 {
   865   if (!update_mode_lines)
   866     update_mode_lines = REDISPLAY_SOME;
   867   b->text->redisplay = true;
   868 }
   869 
   870 void
   871 wset_update_mode_line (struct window *w)
   872 {
   873   w->update_mode_line = true;
   874   /* When a window's mode line needs to be updated, the window's frame's
   875      title may also need to be updated, but we don't need to worry about it
   876      here.  Instead, `gui_consider_frame_title' is automatically called
   877      whenever w->update_mode_line is set for that frame's selected window.
   878      But for this to work reliably, we have to make sure the window
   879      is considered, so we have to mark it for redisplay.  */
   880   wset_redisplay (w);
   881 }
   882 
   883 DEFUN ("set-buffer-redisplay", Fset_buffer_redisplay,
   884        Sset_buffer_redisplay, 4, 4, 0,
   885        doc: /* Mark the current buffer for redisplay.
   886 This function may be passed to `add-variable-watcher'.  */)
   887   (Lisp_Object symbol, Lisp_Object newval, Lisp_Object op, Lisp_Object where)
   888 {
   889   bset_update_mode_line (current_buffer);
   890   current_buffer->prevent_redisplay_optimizations_p = true;
   891   return Qnil;
   892 }
   893 
   894 /* redisplay_trace is for displaying traces of redisplay.
   895    If Emacs was compiled with GLYPH_DEBUG defined, the variable
   896    trace_redisplay_p can be set to a non-zero value in debugging
   897    sessions to activate traces.  */
   898 #ifdef GLYPH_DEBUG
   899 extern bool trace_redisplay_p EXTERNALLY_VISIBLE;
   900 bool trace_redisplay_p;
   901 #else
   902 enum { trace_redisplay_p = false };
   903 #endif
   904 static void ATTRIBUTE_FORMAT_PRINTF (1, 2)
   905 redisplay_trace (char const *fmt, ...)
   906 {
   907   if (trace_redisplay_p)
   908     {
   909       va_list ap;
   910       va_start (ap, fmt);
   911       vprintf (fmt, ap);
   912       va_end (ap);
   913     }
   914 }
   915 
   916 #ifdef DEBUG_TRACE_MOVE
   917 extern bool trace_move EXTERNALLY_VISIBLE;
   918 bool trace_move;
   919 #else
   920 enum { trace_move = false };
   921 #endif
   922 static void ATTRIBUTE_FORMAT_PRINTF (1, 2)
   923 move_trace (char const *fmt, ...)
   924 {
   925   if (trace_move)
   926     {
   927       va_list ap;
   928       va_start (ap, fmt);
   929       vprintf (fmt, ap);
   930       va_end (ap);
   931     }
   932 }
   933 
   934 /* Buffer being redisplayed -- for redisplay_window_error.  */
   935 
   936 static struct buffer *displayed_buffer;
   937 
   938 /* Value returned from text property handlers (see below).  */
   939 
   940 enum prop_handled
   941 {
   942   HANDLED_NORMALLY,
   943   HANDLED_RECOMPUTE_PROPS,
   944   HANDLED_OVERLAY_STRING_CONSUMED,
   945   HANDLED_RETURN
   946 };
   947 
   948 /* A description of text properties that redisplay is interested
   949    in.  */
   950 
   951 struct props
   952 {
   953   /* The symbol index of the name of the property.  */
   954   short name;
   955 
   956   /* A unique index for the property.  */
   957   enum prop_idx idx;
   958 
   959   /* A handler function called to set up iterator IT from the property
   960      at IT's current position.  Value is used to steer handle_stop.  */
   961   enum prop_handled (*handler) (struct it *it);
   962 };
   963 
   964 static enum prop_handled handle_face_prop (struct it *);
   965 static enum prop_handled handle_invisible_prop (struct it *);
   966 static enum prop_handled handle_display_prop (struct it *);
   967 static enum prop_handled handle_composition_prop (struct it *);
   968 static enum prop_handled handle_overlay_change (struct it *);
   969 static enum prop_handled handle_fontified_prop (struct it *);
   970 
   971 /* Properties handled by iterators.  */
   972 
   973 static struct props it_props[] =
   974 {
   975   {SYMBOL_INDEX (Qfontified),   FONTIFIED_PROP_IDX,     handle_fontified_prop},
   976   /* Handle `face' before `display' because some sub-properties of
   977      `display' need to know the face.  */
   978   {SYMBOL_INDEX (Qface),        FACE_PROP_IDX,          handle_face_prop},
   979   {SYMBOL_INDEX (Qdisplay),     DISPLAY_PROP_IDX,       handle_display_prop},
   980   {SYMBOL_INDEX (Qinvisible),   INVISIBLE_PROP_IDX,     handle_invisible_prop},
   981   {SYMBOL_INDEX (Qcomposition), COMPOSITION_PROP_IDX, handle_composition_prop},
   982   {0,                           0,                      NULL}
   983 };
   984 
   985 /* Enumeration returned by some move_it_.* functions internally.  */
   986 
   987 enum move_it_result
   988 {
   989   /* Not used.  Undefined value.  */
   990   MOVE_UNDEFINED,
   991 
   992   /* Move ended at the requested buffer position or ZV.  */
   993   MOVE_POS_MATCH_OR_ZV,
   994 
   995   /* Move ended at the requested X pixel position.  */
   996   MOVE_X_REACHED,
   997 
   998   /* Move within a line ended at the end of a line that must be
   999      continued.  */
  1000   MOVE_LINE_CONTINUED,
  1001 
  1002   /* Move within a line ended at the end of a line that would
  1003      be displayed truncated.  */
  1004   MOVE_LINE_TRUNCATED,
  1005 
  1006   /* Move within a line ended at a line end.  */
  1007   MOVE_NEWLINE_OR_CR
  1008 };
  1009 
  1010 /* This counter is used to clear the face cache every once in a while
  1011    in redisplay_internal.  It is incremented for each redisplay.
  1012    Every CLEAR_FACE_CACHE_COUNT full redisplays, the face cache is
  1013    cleared.  */
  1014 
  1015 #define CLEAR_FACE_CACHE_COUNT  500
  1016 static int clear_face_cache_count;
  1017 
  1018 /* Similarly for the image cache.  */
  1019 
  1020 #ifdef HAVE_WINDOW_SYSTEM
  1021 #define CLEAR_IMAGE_CACHE_COUNT 101
  1022 static int clear_image_cache_count;
  1023 
  1024 /* Null glyph slice */
  1025 static struct glyph_slice null_glyph_slice = { 0, 0, 0, 0 };
  1026 #endif
  1027 
  1028 /* True while redisplay_internal is in progress.  */
  1029 
  1030 bool redisplaying_p;
  1031 
  1032 /* True while some display-engine code is working on layout of some
  1033    window.
  1034 
  1035    WARNING: Use sparingly, preferably only in top level of commands
  1036    and important functions, because using it in nested calls might
  1037    reset the flag when the inner call returns, behind the back of
  1038    the callers.  */
  1039 bool display_working_on_window_p;
  1040 
  1041 /* If a string, XTread_socket generates an event to display that string.
  1042    (The display is done in read_char.)  */
  1043 
  1044 Lisp_Object help_echo_string;
  1045 Lisp_Object help_echo_window;
  1046 Lisp_Object help_echo_object;
  1047 ptrdiff_t help_echo_pos;
  1048 
  1049 /* Temporary variable for XTread_socket.  */
  1050 
  1051 Lisp_Object previous_help_echo_string;
  1052 
  1053 /* Platform-independent portion of hourglass implementation.  */
  1054 
  1055 #ifdef HAVE_WINDOW_SYSTEM
  1056 
  1057 /* True means an hourglass cursor is currently shown.  */
  1058 static bool hourglass_shown_p;
  1059 
  1060 /* If non-null, an asynchronous timer that, when it expires, displays
  1061    an hourglass cursor on all frames.  */
  1062 static struct atimer *hourglass_atimer;
  1063 
  1064 #endif /* HAVE_WINDOW_SYSTEM */
  1065 
  1066 /* Default number of seconds to wait before displaying an hourglass
  1067    cursor.  */
  1068 #define DEFAULT_HOURGLASS_DELAY 1
  1069 
  1070 #ifdef HAVE_WINDOW_SYSTEM
  1071 
  1072 /* Default pixel width of `thin-space' display method.  */
  1073 #define THIN_SPACE_WIDTH 1
  1074 
  1075 #endif /* HAVE_WINDOW_SYSTEM */
  1076 
  1077 /* Function prototypes.  */
  1078 
  1079 static void setup_for_ellipsis (struct it *, int);
  1080 static void set_iterator_to_next (struct it *, bool);
  1081 static void mark_window_display_accurate_1 (struct window *, bool);
  1082 static bool row_for_charpos_p (struct glyph_row *, ptrdiff_t);
  1083 static bool cursor_row_p (struct glyph_row *);
  1084 static int redisplay_mode_lines (Lisp_Object, bool);
  1085 
  1086 static void handle_line_prefix (struct it *);
  1087 
  1088 static void handle_stop_backwards (struct it *, ptrdiff_t);
  1089 static void unwind_with_echo_area_buffer (Lisp_Object);
  1090 static Lisp_Object with_echo_area_buffer_unwind_data (struct window *);
  1091 static bool current_message_1 (void *, Lisp_Object);
  1092 static bool truncate_message_1 (void *, Lisp_Object);
  1093 static void set_message (Lisp_Object);
  1094 static bool set_message_1 (void *, Lisp_Object);
  1095 static bool display_echo_area_1 (void *, Lisp_Object);
  1096 static bool resize_mini_window_1 (void *, Lisp_Object);
  1097 static void unwind_redisplay (void);
  1098 static void extend_face_to_end_of_line (struct it *);
  1099 static intmax_t message_log_check_duplicate (ptrdiff_t, ptrdiff_t);
  1100 static void push_it (struct it *, struct text_pos *);
  1101 static void iterate_out_of_display_property (struct it *);
  1102 static void pop_it (struct it *);
  1103 static void redisplay_internal (void);
  1104 static void echo_area_display (bool);
  1105 static void block_buffer_flips (void);
  1106 static void unblock_buffer_flips (void);
  1107 static void redisplay_windows (Lisp_Object);
  1108 static void redisplay_window (Lisp_Object, bool);
  1109 static Lisp_Object redisplay_window_error (Lisp_Object);
  1110 static Lisp_Object redisplay_window_0 (Lisp_Object);
  1111 static Lisp_Object redisplay_window_1 (Lisp_Object);
  1112 static bool set_cursor_from_row (struct window *, struct glyph_row *,
  1113                                  struct glyph_matrix *, ptrdiff_t, ptrdiff_t,
  1114                                  int, int);
  1115 static bool cursor_row_fully_visible_p (struct window *, bool, bool, bool);
  1116 static bool update_menu_bar (struct frame *, bool, bool);
  1117 static bool try_window_reusing_current_matrix (struct window *);
  1118 static int try_window_id (struct window *);
  1119 static void maybe_produce_line_number (struct it *);
  1120 static bool should_produce_line_number (struct it *);
  1121 static bool display_line (struct it *, int);
  1122 static int display_mode_lines (struct window *);
  1123 static int display_mode_line (struct window *, enum face_id, Lisp_Object);
  1124 static int display_mode_element (struct it *, int, int, int, Lisp_Object,
  1125                                  Lisp_Object, bool);
  1126 static int store_mode_line_string (const char *, Lisp_Object, bool, int, int,
  1127                                    Lisp_Object);
  1128 static const char *decode_mode_spec (struct window *, int, int, Lisp_Object *);
  1129 static void display_menu_bar (struct window *);
  1130 static void display_tab_bar (struct window *);
  1131 static void update_tab_bar (struct frame *, bool);
  1132 static ptrdiff_t display_count_lines (ptrdiff_t, ptrdiff_t, ptrdiff_t,
  1133                                       ptrdiff_t *);
  1134 static void pint2str (register char *, register int, register ptrdiff_t);
  1135 
  1136 static int display_string (const char *, Lisp_Object, Lisp_Object,
  1137                            ptrdiff_t, ptrdiff_t, struct it *, int, int, int,
  1138                            int);
  1139 static void compute_line_metrics (struct it *);
  1140 static bool get_overlay_strings (struct it *, ptrdiff_t);
  1141 static bool get_overlay_strings_1 (struct it *, ptrdiff_t, bool);
  1142 static void next_overlay_string (struct it *);
  1143 static void reseat (struct it *, struct text_pos, bool);
  1144 static void reseat_1 (struct it *, struct text_pos, bool);
  1145 static bool next_element_from_display_vector (struct it *);
  1146 static bool next_element_from_string (struct it *);
  1147 static bool next_element_from_c_string (struct it *);
  1148 static bool next_element_from_buffer (struct it *);
  1149 static bool next_element_from_composition (struct it *);
  1150 static bool next_element_from_image (struct it *);
  1151 static bool next_element_from_stretch (struct it *);
  1152 static bool next_element_from_xwidget (struct it *);
  1153 static void load_overlay_strings (struct it *, ptrdiff_t);
  1154 static bool get_next_display_element (struct it *);
  1155 static enum move_it_result
  1156        move_it_in_display_line_to (struct it *, ptrdiff_t, int,
  1157                                    enum move_operation_enum);
  1158 static void get_visually_first_element (struct it *);
  1159 static void compute_stop_pos (struct it *);
  1160 static int face_before_or_after_it_pos (struct it *, bool);
  1161 static int handle_display_spec (struct it *, Lisp_Object, Lisp_Object,
  1162                                 Lisp_Object, struct text_pos *, ptrdiff_t, bool);
  1163 static int handle_single_display_spec (struct it *, Lisp_Object, Lisp_Object,
  1164                                        Lisp_Object, struct text_pos *,
  1165                                        ptrdiff_t, int, bool, bool);
  1166 static int underlying_face_id (const struct it *);
  1167 
  1168 #define face_before_it_pos(IT) face_before_or_after_it_pos (IT, true)
  1169 #define face_after_it_pos(IT)  face_before_or_after_it_pos (IT, false)
  1170 
  1171 #ifdef HAVE_WINDOW_SYSTEM
  1172 
  1173 static void update_tool_bar (struct frame *, bool);
  1174 static void gui_draw_bottom_divider (struct window *w);
  1175 static void notice_overwritten_cursor (struct window *,
  1176                                        enum glyph_row_area,
  1177                                        int, int, int, int);
  1178 static int  normal_char_height (struct font *, int);
  1179 static void normal_char_ascent_descent (struct font *, int, int *, int *);
  1180 
  1181 static void append_stretch_glyph (struct it *, Lisp_Object,
  1182                                   int, int, int);
  1183 
  1184 static Lisp_Object get_it_property (struct it *, Lisp_Object);
  1185 static Lisp_Object calc_line_height_property (struct it *, Lisp_Object,
  1186                                               struct font *, int, bool);
  1187 static int adjust_glyph_width_for_mouse_face (struct glyph *,
  1188                                               struct glyph_row *,
  1189                                               struct window *, struct face *,
  1190                                               struct face *);
  1191 static void get_cursor_offset_for_mouse_face (struct window *w,
  1192                                               struct glyph_row *row,
  1193                                               int *offset);
  1194 #endif /* HAVE_WINDOW_SYSTEM */
  1195 
  1196 static void produce_special_glyphs (struct it *, enum display_element_type);
  1197 static void pad_mode_line (struct it *, bool);
  1198 static void show_mouse_face (Mouse_HLInfo *, enum draw_glyphs_face);
  1199 static bool coords_in_mouse_face_p (struct window *, int, int);
  1200 static void reset_box_start_end_flags (struct it *);
  1201 
  1202 
  1203 
  1204 /***********************************************************************
  1205                       Window display dimensions
  1206  ***********************************************************************/
  1207 
  1208 /* Return the bottom boundary y-position for text lines in window W.
  1209    This is the first y position at which a line cannot start.
  1210    It is relative to the top of the window.
  1211 
  1212    This is the height of W minus the height of a mode line, if any.  */
  1213 
  1214 int
  1215 window_text_bottom_y (struct window *w)
  1216 {
  1217   int height = WINDOW_PIXEL_HEIGHT (w);
  1218 
  1219   height -= WINDOW_BOTTOM_DIVIDER_WIDTH (w);
  1220 
  1221   if (window_wants_mode_line (w))
  1222     height -= CURRENT_MODE_LINE_HEIGHT (w);
  1223 
  1224   height -= WINDOW_SCROLL_BAR_AREA_HEIGHT (w);
  1225 
  1226   return height;
  1227 }
  1228 
  1229 /* Return the pixel width of display area AREA of window W.
  1230    ANY_AREA means return the total width of W, not including
  1231    fringes to the left and right of the window.  */
  1232 
  1233 int
  1234 window_box_width (struct window *w, enum glyph_row_area area)
  1235 {
  1236   int width = w->pixel_width;
  1237 
  1238   if (!w->pseudo_window_p)
  1239     {
  1240       width -= WINDOW_SCROLL_BAR_AREA_WIDTH (w);
  1241       width -= WINDOW_RIGHT_DIVIDER_WIDTH (w);
  1242 
  1243       if (area == TEXT_AREA)
  1244         width -= (WINDOW_MARGINS_WIDTH (w)
  1245                    + WINDOW_FRINGES_WIDTH (w));
  1246       else if (area == LEFT_MARGIN_AREA)
  1247         width = WINDOW_LEFT_MARGIN_WIDTH (w);
  1248       else if (area == RIGHT_MARGIN_AREA)
  1249         width = WINDOW_RIGHT_MARGIN_WIDTH (w);
  1250     }
  1251 
  1252   /* With wide margins, fringes, etc. we might end up with a negative
  1253      width, correct that here.  */
  1254   return max (0, width);
  1255 }
  1256 
  1257 
  1258 /* Return the pixel height of the display area of window W, not
  1259    including mode lines of W, if any.  */
  1260 
  1261 int
  1262 window_box_height (struct window *w)
  1263 {
  1264   struct frame *f = XFRAME (w->frame);
  1265   int height = WINDOW_PIXEL_HEIGHT (w);
  1266 
  1267   eassert (height >= 0);
  1268 
  1269   height -= WINDOW_BOTTOM_DIVIDER_WIDTH (w);
  1270   height -= WINDOW_SCROLL_BAR_AREA_HEIGHT (w);
  1271 
  1272   /* Note: the code below that determines the mode-line/header-line/tab-line
  1273      height is essentially the same as that contained in the macro
  1274      CURRENT_{MODE,HEADER,TAB}_LINE_HEIGHT, except that it checks whether
  1275      the appropriate glyph row has its `mode_line_p' flag set, and if
  1276      it doesn't, uses estimate_mode_line_height instead.  */
  1277 
  1278   if (window_wants_mode_line (w))
  1279     {
  1280       if (w->mode_line_height >= 0)
  1281         height -= w->mode_line_height;
  1282       else
  1283         {
  1284           struct glyph_row *ml_row
  1285             = (w->current_matrix && w->current_matrix->rows
  1286                ? MATRIX_MODE_LINE_ROW (w->current_matrix)
  1287                : 0);
  1288           if (ml_row && ml_row->mode_line_p)
  1289             height -= ml_row->height;
  1290           else
  1291             height -= estimate_mode_line_height
  1292               (f, CURRENT_MODE_LINE_ACTIVE_FACE_ID (w));
  1293         }
  1294     }
  1295 
  1296   if (window_wants_tab_line (w))
  1297     {
  1298       if (w->tab_line_height >= 0)
  1299         height -= w->tab_line_height;
  1300       else
  1301         {
  1302           struct glyph_row *tl_row
  1303             = (w->current_matrix && w->current_matrix->rows
  1304                ? MATRIX_TAB_LINE_ROW (w->current_matrix)
  1305                : 0);
  1306           if (tl_row && tl_row->mode_line_p)
  1307             height -= tl_row->height;
  1308           else
  1309             height -= estimate_mode_line_height (f, TAB_LINE_FACE_ID);
  1310         }
  1311     }
  1312 
  1313   if (window_wants_header_line (w))
  1314     {
  1315       if (w->header_line_height >= 0)
  1316         height -= w->header_line_height;
  1317       else
  1318         {
  1319           struct glyph_row *hl_row
  1320             = (w->current_matrix && w->current_matrix->rows
  1321                ? MATRIX_HEADER_LINE_ROW (w->current_matrix)
  1322                : 0);
  1323           if (hl_row && hl_row->mode_line_p)
  1324             height -= hl_row->height;
  1325           else
  1326             height -= estimate_mode_line_height (f, HEADER_LINE_FACE_ID);
  1327         }
  1328     }
  1329 
  1330   /* With a very small font and a mode-line that's taller than
  1331      default, we might end up with a negative height.  */
  1332   return max (0, height);
  1333 }
  1334 
  1335 /* Return the window-relative coordinate of the left edge of display
  1336    area AREA of window W.  ANY_AREA means return the left edge of the
  1337    whole window, to the right of the left fringe of W.  */
  1338 
  1339 int
  1340 window_box_left_offset (struct window *w, enum glyph_row_area area)
  1341 {
  1342   int x;
  1343 
  1344   if (w->pseudo_window_p)
  1345     return 0;
  1346 
  1347   x = WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w);
  1348 
  1349   if (area == TEXT_AREA)
  1350     x += (WINDOW_LEFT_FRINGE_WIDTH (w)
  1351           + window_box_width (w, LEFT_MARGIN_AREA));
  1352   else if (area == RIGHT_MARGIN_AREA)
  1353     x += (WINDOW_LEFT_FRINGE_WIDTH (w)
  1354           + window_box_width (w, LEFT_MARGIN_AREA)
  1355           + window_box_width (w, TEXT_AREA)
  1356           + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
  1357              ? 0
  1358              : WINDOW_RIGHT_FRINGE_WIDTH (w)));
  1359   else if (area == LEFT_MARGIN_AREA
  1360            && WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
  1361     x += WINDOW_LEFT_FRINGE_WIDTH (w);
  1362 
  1363   /* Don't return more than the window's pixel width.  */
  1364   return min (x, w->pixel_width);
  1365 }
  1366 
  1367 
  1368 /* Return the window-relative coordinate of the right edge of display
  1369    area AREA of window W.  ANY_AREA means return the right edge of the
  1370    whole window, to the left of the right fringe of W.  */
  1371 
  1372 static int
  1373 window_box_right_offset (struct window *w, enum glyph_row_area area)
  1374 {
  1375   /* Don't return more than the window's pixel width.  */
  1376   return min (window_box_left_offset (w, area) + window_box_width (w, area),
  1377               w->pixel_width);
  1378 }
  1379 
  1380 /* Return the frame-relative coordinate of the left edge of display
  1381    area AREA of window W.  ANY_AREA means return the left edge of the
  1382    whole window, to the right of the left fringe of W.  */
  1383 
  1384 int
  1385 window_box_left (struct window *w, enum glyph_row_area area)
  1386 {
  1387   struct frame *f = XFRAME (w->frame);
  1388   int x;
  1389 
  1390   if (w->pseudo_window_p)
  1391     return FRAME_INTERNAL_BORDER_WIDTH (f);
  1392 
  1393   x = (WINDOW_LEFT_EDGE_X (w)
  1394        + window_box_left_offset (w, area));
  1395 
  1396   return x;
  1397 }
  1398 
  1399 
  1400 /* Return the frame-relative coordinate of the right edge of display
  1401    area AREA of window W.  ANY_AREA means return the right edge of the
  1402    whole window, to the left of the right fringe of W.  */
  1403 
  1404 int
  1405 window_box_right (struct window *w, enum glyph_row_area area)
  1406 {
  1407   return window_box_left (w, area) + window_box_width (w, area);
  1408 }
  1409 
  1410 /* Get the bounding box of the display area AREA of window W, without
  1411    mode lines, in frame-relative coordinates.  ANY_AREA means the
  1412    whole window, not including the left and right fringes of
  1413    the window.  Return in *BOX_X and *BOX_Y the frame-relative pixel
  1414    coordinates of the upper-left corner of the box.  Return in
  1415    *BOX_WIDTH, and *BOX_HEIGHT the pixel width and height of the box.  */
  1416 
  1417 void
  1418 window_box (struct window *w, enum glyph_row_area area, int *box_x,
  1419             int *box_y, int *box_width, int *box_height)
  1420 {
  1421   if (box_width)
  1422     *box_width = window_box_width (w, area);
  1423   if (box_height)
  1424     *box_height = window_box_height (w);
  1425   if (box_x)
  1426     *box_x = window_box_left (w, area);
  1427   if (box_y)
  1428     {
  1429       *box_y = WINDOW_TOP_EDGE_Y (w);
  1430       if (window_wants_tab_line (w))
  1431         *box_y += CURRENT_TAB_LINE_HEIGHT (w);
  1432       if (window_wants_header_line (w))
  1433         *box_y += CURRENT_HEADER_LINE_HEIGHT (w);
  1434     }
  1435 }
  1436 
  1437 #ifdef HAVE_WINDOW_SYSTEM
  1438 
  1439 /* Get the bounding box of the display area AREA of window W, without
  1440    mode lines and both fringes of the window.  Return in *TOP_LEFT_X
  1441    and TOP_LEFT_Y the frame-relative pixel coordinates of the
  1442    upper-left corner of the box.  Return in *BOTTOM_RIGHT_X, and
  1443    *BOTTOM_RIGHT_Y the coordinates of the bottom-right corner of the
  1444    box.  */
  1445 
  1446 static void
  1447 window_box_edges (struct window *w, int *top_left_x, int *top_left_y,
  1448                   int *bottom_right_x, int *bottom_right_y)
  1449 {
  1450   window_box (w, ANY_AREA, top_left_x, top_left_y,
  1451               bottom_right_x, bottom_right_y);
  1452   *bottom_right_x += *top_left_x;
  1453   *bottom_right_y += *top_left_y;
  1454 }
  1455 
  1456 #endif /* HAVE_WINDOW_SYSTEM */
  1457 
  1458 /***********************************************************************
  1459                               Utilities
  1460  ***********************************************************************/
  1461 
  1462 /* Return the bottom y-position of the line the iterator IT is in.
  1463    This can modify IT's settings.  */
  1464 
  1465 int
  1466 line_bottom_y (struct it *it)
  1467 {
  1468   int line_height = it->max_ascent + it->max_descent;
  1469   int line_top_y = it->current_y;
  1470 
  1471   if (line_height == 0)
  1472     {
  1473       if (last_height)
  1474         line_height = last_height;
  1475       else if (IT_CHARPOS (*it) < ZV)
  1476         {
  1477           move_it_by_lines (it, 1);
  1478           line_height = (it->max_ascent || it->max_descent
  1479                          ? it->max_ascent + it->max_descent
  1480                          : last_height);
  1481         }
  1482       else
  1483         {
  1484           struct glyph_row *row = it->glyph_row;
  1485 
  1486           /* Use the default character height.  */
  1487           it->glyph_row = NULL;
  1488           it->what = IT_CHARACTER;
  1489           it->c = ' ';
  1490           it->len = 1;
  1491           PRODUCE_GLYPHS (it);
  1492           line_height = it->ascent + it->descent;
  1493           it->glyph_row = row;
  1494         }
  1495     }
  1496 
  1497   return line_top_y + line_height;
  1498 }
  1499 
  1500 DEFUN ("line-pixel-height", Fline_pixel_height,
  1501        Sline_pixel_height, 0, 0, 0,
  1502        doc: /* Return height in pixels of text line in the selected window.
  1503 
  1504 Value is the height in pixels of the line at point.  */)
  1505   (void)
  1506 {
  1507   struct it it;
  1508   struct text_pos pt;
  1509   struct window *w = XWINDOW (selected_window);
  1510   struct buffer *old_buffer = NULL;
  1511   Lisp_Object result;
  1512 
  1513   if (XBUFFER (w->contents) != current_buffer)
  1514     {
  1515       old_buffer = current_buffer;
  1516       set_buffer_internal_1 (XBUFFER (w->contents));
  1517     }
  1518   SET_TEXT_POS (pt, PT, PT_BYTE);
  1519   void *itdata = bidi_shelve_cache ();
  1520   start_display (&it, w, pt);
  1521   /* Start from the beginning of the screen line, to make sure we
  1522      traverse all of its display elements, and thus capture the
  1523      correct metrics.  */
  1524   move_it_by_lines (&it, 0);
  1525   it.vpos = it.current_y = 0;
  1526   last_height = 0;
  1527   result = make_fixnum (line_bottom_y (&it));
  1528   if (old_buffer)
  1529     set_buffer_internal_1 (old_buffer);
  1530 
  1531   bidi_unshelve_cache (itdata, false);
  1532   return result;
  1533 }
  1534 
  1535 /* Return the default pixel height of text lines in window W.  The
  1536    value is the canonical height of the W frame's default font, plus
  1537    any extra space required by the line-spacing variable or frame
  1538    parameter.
  1539 
  1540    Implementation note: this ignores any line-spacing text properties
  1541    put on the newline characters.  This is because those properties
  1542    only affect the _screen_ line ending in the newline (i.e., in a
  1543    continued line, only the last screen line will be affected), which
  1544    means only a small number of lines in a buffer can ever use this
  1545    feature.  Since this function is used to compute the default pixel
  1546    equivalent of text lines in a window, we can safely ignore those
  1547    few lines.  For the same reasons, we ignore the line-height
  1548    properties.  */
  1549 int
  1550 default_line_pixel_height (struct window *w)
  1551 {
  1552   struct frame *f = WINDOW_XFRAME (w);
  1553   int height = FRAME_LINE_HEIGHT (f);
  1554 
  1555   if (!FRAME_INITIAL_P (f) && BUFFERP (w->contents))
  1556     {
  1557       struct buffer *b = XBUFFER (w->contents);
  1558       Lisp_Object val = BVAR (b, extra_line_spacing);
  1559 
  1560       if (NILP (val))
  1561         val = BVAR (&buffer_defaults, extra_line_spacing);
  1562       if (!NILP (val))
  1563         {
  1564           if (RANGED_FIXNUMP (0, val, INT_MAX))
  1565             height += XFIXNAT (val);
  1566           else if (FLOATP (val))
  1567             {
  1568               int addon = XFLOAT_DATA (val) * height + 0.5;
  1569 
  1570               if (addon >= 0)
  1571                 height += addon;
  1572             }
  1573         }
  1574       else
  1575         height += f->extra_line_spacing;
  1576     }
  1577 
  1578   return height;
  1579 }
  1580 
  1581 /* Subroutine of pos_visible_p below.  Extracts a display string, if
  1582    any, from the display spec given as its argument.  */
  1583 static Lisp_Object
  1584 string_from_display_spec (Lisp_Object spec)
  1585 {
  1586   if (VECTORP (spec))
  1587     {
  1588       for (ptrdiff_t i = 0; i < ASIZE (spec); i++)
  1589         if (STRINGP (AREF (spec, i)))
  1590           return AREF (spec, i);
  1591     }
  1592   else
  1593     {
  1594       for (; CONSP (spec); spec = XCDR (spec))
  1595         if (STRINGP (XCAR (spec)))
  1596           return XCAR (spec);
  1597     }
  1598   return spec;
  1599 }
  1600 
  1601 
  1602 /* Limit insanely large values of W->hscroll on frame F to the largest
  1603    value that will still prevent first_visible_x and last_visible_x of
  1604    'struct it' from overflowing an int.  */
  1605 static int
  1606 window_hscroll_limited (struct window *w, struct frame *f)
  1607 {
  1608   ptrdiff_t window_hscroll = w->hscroll;
  1609   int window_text_width = window_box_width (w, TEXT_AREA);
  1610   int colwidth = FRAME_COLUMN_WIDTH (f);
  1611 
  1612   if (window_hscroll > (INT_MAX - window_text_width) / colwidth - 1)
  1613     window_hscroll = (INT_MAX - window_text_width) / colwidth - 1;
  1614 
  1615   return window_hscroll;
  1616 }
  1617 
  1618 /* Reset the box-face start and end flags in the iterator.  This is
  1619    called after producing glyphs, such that we reset these flags only
  1620    after producing a glyph with the flag set.  */
  1621 
  1622 static void
  1623 reset_box_start_end_flags (struct it *it)
  1624 {
  1625   /* Don't reset if we've drawn the glyph in the display margins --
  1626      those don't count as "produced glyphs".  */
  1627   if (it->area == TEXT_AREA
  1628       /* Don't reset if we displayed a fringe bitmap.  */
  1629       && !(it->what == IT_IMAGE && it->image_id < 0))
  1630     {
  1631       /* Don't reset if the face is not a box face: that might mean we
  1632          are iterating some overlay or display string, and the first
  1633          character to have the box face is yet to be seen, when we pop
  1634          the iterator stack. */
  1635       if (it->face_box_p)
  1636         it->start_of_box_run_p = false;
  1637       it->end_of_box_run_p = false;
  1638     }
  1639 }
  1640 
  1641 /* Return true if position CHARPOS is visible in window W.
  1642    CHARPOS < 0 means return info about WINDOW_END position.
  1643    If visible, set *X and *Y to pixel coordinates of top left corner.
  1644    Set *RTOP and *RBOT to pixel height of an invisible area of glyph at POS.
  1645    Set *ROWH and *VPOS to row's visible height and VPOS (row number).  */
  1646 
  1647 bool
  1648 pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
  1649                int *rtop, int *rbot, int *rowh, int *vpos)
  1650 {
  1651   struct it it;
  1652   void *itdata = bidi_shelve_cache ();
  1653   struct text_pos top;
  1654   bool visible_p = false;
  1655   struct buffer *old_buffer = NULL;
  1656   bool r2l = false;
  1657 
  1658   if (FRAME_INITIAL_P (XFRAME (WINDOW_FRAME (w))))
  1659     return visible_p;
  1660 
  1661   if (XBUFFER (w->contents) != current_buffer)
  1662     {
  1663       old_buffer = current_buffer;
  1664       set_buffer_internal_1 (XBUFFER (w->contents));
  1665     }
  1666 
  1667   SET_TEXT_POS_FROM_MARKER (top, w->start);
  1668   /* Scrolling a minibuffer window via scroll bar when the echo area
  1669      shows long text sometimes resets the minibuffer contents behind
  1670      our backs.  Also, someone might narrow-to-region and immediately
  1671      call a scroll function.  */
  1672   if (CHARPOS (top) > ZV || CHARPOS (top) < BEGV)
  1673     SET_TEXT_POS (top, BEGV, BEGV_BYTE);
  1674 
  1675   /* If the top of the window is after CHARPOS, the latter is surely
  1676      not visible.  */
  1677   if (charpos >= 0 && CHARPOS (top) > charpos)
  1678     return visible_p;
  1679 
  1680   /* Some Lisp hook could call us in the middle of redisplaying this
  1681      very window.  If, by some bad luck, we are retrying redisplay
  1682      because we found that the mode-line height and/or tab/header-line
  1683      height needs to be updated, the assignment of mode_line_height
  1684      and header_line_height below could disrupt that, due to the
  1685      selected/nonselected window dance during mode-line display, and
  1686      we could infloop.  Avoid that.  */
  1687   int prev_mode_line_height = w->mode_line_height;
  1688   int prev_header_line_height = w->header_line_height;
  1689   int prev_tab_line_height = w->tab_line_height;
  1690   /* Compute exact mode line heights.  */
  1691   if (window_wants_mode_line (w))
  1692     {
  1693       Lisp_Object window_mode_line_format
  1694         = window_parameter (w, Qmode_line_format);
  1695 
  1696       w->mode_line_height
  1697         = display_mode_line (w, CURRENT_MODE_LINE_ACTIVE_FACE_ID (w),
  1698                              NILP (window_mode_line_format)
  1699                              ? BVAR (current_buffer, mode_line_format)
  1700                              : window_mode_line_format);
  1701     }
  1702 
  1703   if (window_wants_tab_line (w))
  1704     {
  1705       Lisp_Object window_tab_line_format
  1706         = window_parameter (w, Qtab_line_format);
  1707 
  1708       w->tab_line_height
  1709         = display_mode_line (w, TAB_LINE_FACE_ID,
  1710                              NILP (window_tab_line_format)
  1711                              ? BVAR (current_buffer, tab_line_format)
  1712                              : window_tab_line_format);
  1713     }
  1714 
  1715   if (window_wants_header_line (w))
  1716     {
  1717       Lisp_Object window_header_line_format
  1718         = window_parameter (w, Qheader_line_format);
  1719 
  1720       w->header_line_height
  1721         = display_mode_line (w, HEADER_LINE_FACE_ID,
  1722                              NILP (window_header_line_format)
  1723                              ? BVAR (current_buffer, header_line_format)
  1724                              : window_header_line_format);
  1725     }
  1726 
  1727   start_display (&it, w, top);
  1728   move_it_to (&it, charpos, -1, it.last_visible_y - 1, -1,
  1729               (charpos >= 0 ? MOVE_TO_POS : 0) | MOVE_TO_Y);
  1730 
  1731   /* Adjust for line numbers, if CHARPOS is at or beyond first_visible_x,
  1732      but we didn't yet produce the line-number glyphs.  */
  1733   if (!NILP (Vdisplay_line_numbers)
  1734       && it.current_x >= it.first_visible_x
  1735       && IT_CHARPOS (it) == charpos
  1736       && !it.line_number_produced_p)
  1737     {
  1738       /* If the pixel width of line numbers was not yet known, compute
  1739          it now.  This usually happens in the first display line of a
  1740          window.  */
  1741       if (!it.lnum_pixel_width)
  1742         {
  1743           struct it it2;
  1744           void *it2data = NULL;
  1745 
  1746           SAVE_IT (it2, it, it2data);
  1747           move_it_by_lines (&it, 1);
  1748           it2.lnum_pixel_width = it.lnum_pixel_width;
  1749           RESTORE_IT (&it, &it2, it2data);
  1750         }
  1751       it.current_x += it.lnum_pixel_width;
  1752     }
  1753 
  1754   if (charpos >= 0
  1755       && (((!it.bidi_p || it.bidi_it.scan_dir != -1)
  1756            && IT_CHARPOS (it) >= charpos)
  1757           /* When scanning backwards under bidi iteration, move_it_to
  1758              stops at or _before_ CHARPOS, because it stops at or to
  1759              the _right_ of the character at CHARPOS.  */
  1760           || (it.bidi_p && it.bidi_it.scan_dir == -1
  1761               && IT_CHARPOS (it) <= charpos)))
  1762     {
  1763       /* We have reached CHARPOS, or passed it.  How the call to
  1764          move_it_to can overshoot: (i) If CHARPOS is on invisible text
  1765          or covered by a display property, move_it_to stops at the end
  1766          of the invisible text, to the right of CHARPOS.  (ii) If
  1767          CHARPOS is in a display vector, move_it_to stops on its last
  1768          glyph.  */
  1769       int top_x = it.current_x;
  1770       int top_y = it.current_y;
  1771       int window_top_y = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
  1772       int bottom_y;
  1773       struct it save_it;
  1774       void *save_it_data = NULL;
  1775 
  1776       /* Calling line_bottom_y may change it.method, it.position, etc.  */
  1777       SAVE_IT (save_it, it, save_it_data);
  1778       last_height = 0;
  1779       bottom_y = line_bottom_y (&it);
  1780       if (top_y < window_top_y)
  1781         visible_p = bottom_y > window_top_y;
  1782       else if (top_y < it.last_visible_y)
  1783         visible_p = true;
  1784       if (bottom_y >= it.last_visible_y
  1785           && it.bidi_p && it.bidi_it.scan_dir == -1
  1786           && IT_CHARPOS (it) < charpos)
  1787         {
  1788           /* When the last line of the window is scanned backwards
  1789              under bidi iteration, we could be duped into thinking
  1790              that we have passed CHARPOS, when in fact move_it_to
  1791              simply stopped short of CHARPOS because it reached
  1792              last_visible_y.  To see if that's what happened, we call
  1793              move_it_to again with a slightly larger vertical limit,
  1794              and see if it actually moved vertically; if it did, we
  1795              didn't really reach CHARPOS, which is beyond window end.  */
  1796           /* Why 10? because we don't know how many canonical lines
  1797              will the height of the next line(s) be.  So we guess.  */
  1798           int ten_more_lines = 10 * default_line_pixel_height (w);
  1799 
  1800           move_it_to (&it, charpos, -1, bottom_y + ten_more_lines, -1,
  1801                       MOVE_TO_POS | MOVE_TO_Y);
  1802           if (it.current_y > top_y)
  1803             visible_p = false;
  1804 
  1805         }
  1806       RESTORE_IT (&it, &save_it, save_it_data);
  1807       if (visible_p)
  1808         {
  1809           if (it.method == GET_FROM_DISPLAY_VECTOR)
  1810             {
  1811               /* We stopped on the last glyph of a display vector.
  1812                  Try and recompute.  Hack alert!  */
  1813               if (charpos < 2 || top.charpos >= charpos)
  1814                 top_x = it.glyph_row->x;
  1815               else
  1816                 {
  1817                   struct it it2, it2_prev;
  1818                   /* The idea is to get to the previous buffer
  1819                      position, consume the character there, and use
  1820                      the pixel coordinates we get after that.  But if
  1821                      the previous buffer position is also displayed
  1822                      from a display vector, we need to consume all of
  1823                      the glyphs from that display vector.  */
  1824                   start_display (&it2, w, top);
  1825                   it2.glyph_row = NULL;
  1826                   move_it_to (&it2, charpos - 1, -1, -1, -1, MOVE_TO_POS);
  1827                   /* If we didn't get to CHARPOS - 1, there's some
  1828                      replacing display property at that position, and
  1829                      we stopped after it.  That is exactly the place
  1830                      whose coordinates we want.  */
  1831                   if (IT_CHARPOS (it2) != charpos - 1)
  1832                     it2_prev = it2;
  1833                   else
  1834                     {
  1835                       /* Iterate until we get out of the display
  1836                          vector that displays the character at
  1837                          CHARPOS - 1.  */
  1838                       do {
  1839                         get_next_display_element (&it2);
  1840                         PRODUCE_GLYPHS (&it2);
  1841                         it2_prev = it2;
  1842                         set_iterator_to_next (&it2, true);
  1843                       } while (it2.method == GET_FROM_DISPLAY_VECTOR
  1844                                && IT_CHARPOS (it2) < charpos);
  1845                     }
  1846                   if (ITERATOR_AT_END_OF_LINE_P (&it2_prev)
  1847                       || it2_prev.current_x > it2_prev.last_visible_x)
  1848                     top_x = it.glyph_row->x;
  1849                   else
  1850                     {
  1851                       top_x = it2_prev.current_x;
  1852                       top_y = it2_prev.current_y;
  1853                     }
  1854                 }
  1855             }
  1856           else if (IT_CHARPOS (it) != charpos)
  1857             {
  1858               Lisp_Object cpos = make_fixnum (charpos);
  1859               Lisp_Object spec = Fget_char_property (cpos, Qdisplay, Qnil);
  1860               Lisp_Object string = string_from_display_spec (spec);
  1861               struct text_pos tpos;
  1862               bool newline_in_string
  1863                 = (STRINGP (string)
  1864                    && memchr (SDATA (string), '\n', SBYTES (string)));
  1865 
  1866               SET_TEXT_POS (tpos, charpos, CHAR_TO_BYTE (charpos));
  1867               bool replacing_spec_p
  1868                 = (!NILP (spec)
  1869                    && handle_display_spec (NULL, spec, Qnil, Qnil, &tpos,
  1870                                            charpos, FRAME_WINDOW_P (it.f)));
  1871               /* The tricky code below is needed because there's a
  1872                  discrepancy between move_it_to and how we set cursor
  1873                  when PT is at the beginning of a portion of text
  1874                  covered by a display property or an overlay with a
  1875                  display property, or the display line ends in a
  1876                  newline from a display string.  move_it_to will stop
  1877                  _after_ such display strings, whereas
  1878                  set_cursor_from_row conspires with cursor_row_p to
  1879                  place the cursor on the first glyph produced from the
  1880                  display string.  */
  1881 
  1882               /* We have overshoot PT because it is covered by a
  1883                  display property that replaces the text it covers.
  1884                  If the string includes embedded newlines, we are also
  1885                  in the wrong display line.  Backtrack to the correct
  1886                  line, where the display property begins.  */
  1887               if (replacing_spec_p)
  1888                 {
  1889                   Lisp_Object startpos, endpos;
  1890                   EMACS_INT start, end;
  1891                   struct it it3;
  1892 
  1893                   /* Find the first and the last buffer positions
  1894                      covered by the display string.  */
  1895                   endpos =
  1896                     Fnext_single_char_property_change (cpos, Qdisplay,
  1897                                                        Qnil, Qnil);
  1898                   startpos =
  1899                     Fprevious_single_char_property_change (endpos, Qdisplay,
  1900                                                            Qnil, Qnil);
  1901                   start = XFIXNAT (startpos);
  1902                   end = XFIXNAT (endpos);
  1903                   /* Move to the last buffer position before the
  1904                      display property.  */
  1905                   start_display (&it3, w, top);
  1906                   if (start > CHARPOS (top))
  1907                     move_it_to (&it3, start - 1, -1, -1, -1, MOVE_TO_POS);
  1908                   /* Move forward one more line if the position before
  1909                      the display string is a newline or if it is the
  1910                      rightmost character on a line that is
  1911                      continued or word-wrapped.  */
  1912                   if (it3.method == GET_FROM_BUFFER
  1913                       && (it3.c == '\n'
  1914                           || FETCH_BYTE (IT_BYTEPOS (it3)) == '\n'))
  1915                     move_it_by_lines (&it3, 1);
  1916                   else if (move_it_in_display_line_to (&it3, -1,
  1917                                                        it3.current_x
  1918                                                        + it3.pixel_width,
  1919                                                        MOVE_TO_X)
  1920                            == MOVE_LINE_CONTINUED)
  1921                     {
  1922                       move_it_by_lines (&it3, 1);
  1923                       /* When we are under word-wrap, the #$@%!
  1924                          move_it_by_lines moves 2 lines, so we need to
  1925                          fix that up.  */
  1926                       if (it3.line_wrap == WORD_WRAP)
  1927                         move_it_by_lines (&it3, -1);
  1928                     }
  1929 
  1930                   /* Record the vertical coordinate of the display
  1931                      line where we wound up.  */
  1932                   top_y = it3.current_y;
  1933                   if (it3.bidi_p)
  1934                     {
  1935                       /* When characters are reordered for display,
  1936                          the character displayed to the left of the
  1937                          display string could be _after_ the display
  1938                          property in the logical order.  Use the
  1939                          smallest vertical position of these two.  */
  1940                       start_display (&it3, w, top);
  1941                       move_it_to (&it3, end + 1, -1, -1, -1, MOVE_TO_POS);
  1942                       if (it3.current_y < top_y)
  1943                         top_y = it3.current_y;
  1944                     }
  1945                   /* Move from the top of the window to the beginning
  1946                      of the display line where the display string
  1947                      begins.  */
  1948                   start_display (&it3, w, top);
  1949                   it3.glyph_row = NULL;
  1950                   move_it_to (&it3, -1, 0, top_y, -1, MOVE_TO_X | MOVE_TO_Y);
  1951                   /* If it3_moved stays false after the 'while' loop
  1952                      below, that means we already were at a newline
  1953                      before the loop (e.g., the display string begins
  1954                      with a newline), so we don't need to return to
  1955                      the last position before the display string,
  1956                      because PRODUCE_GLYPHS will not produce anything
  1957                      for a newline.  */
  1958                   bool it3_moved = false;
  1959                   int top_x_before_string = it3.current_x;
  1960                   /* Finally, advance the iterator until we hit the
  1961                      first display element whose character position is
  1962                      at or beyond CHARPOS, or until the first newline
  1963                      from the display string, which signals the end of
  1964                      the display line.  */
  1965                   while (get_next_display_element (&it3))
  1966                     {
  1967                       if (!EQ (it3.object, string))
  1968                         top_x_before_string = it3.current_x;
  1969                       PRODUCE_GLYPHS (&it3);
  1970                       if ((it3.bidi_it.scan_dir == 1
  1971                            && IT_CHARPOS (it3) >= charpos)
  1972                           || (it3.bidi_it.scan_dir == -1
  1973                               && IT_CHARPOS (it3) <= charpos)
  1974                           || ITERATOR_AT_END_OF_LINE_P (&it3))
  1975                         break;
  1976                       it3_moved = true;
  1977                       set_iterator_to_next (&it3, false);
  1978                     }
  1979                   top_x = it3.current_x - it3.pixel_width;
  1980                   /* Account for line-number display, if IT3 still
  1981                      didn't.  This can happen if START - 1 is the
  1982                      first or the last character on its display line.  */
  1983                   if (!it3.line_number_produced_p)
  1984                     {
  1985                       if (it3.lnum_pixel_width > 0)
  1986                         {
  1987                           top_x += it3.lnum_pixel_width;
  1988                           top_x_before_string += it3.lnum_pixel_width;
  1989                         }
  1990                       else if (it.line_number_produced_p)
  1991                         {
  1992                           top_x += it.lnum_pixel_width;
  1993                           top_x_before_string += it3.lnum_pixel_width;
  1994                         }
  1995                     }
  1996                   /* Normally, we would exit the above loop because we
  1997                      found the display element whose character
  1998                      position is CHARPOS.  For the contingency that we
  1999                      didn't, and stopped at the first newline from the
  2000                      display string, reset top_x to the coordinate of
  2001                      the rightmost glyph not from the string.  */
  2002                   if (it3_moved
  2003                       && newline_in_string
  2004                       && IT_CHARPOS (it3) != charpos && EQ (it3.object, string))
  2005                     top_x = top_x_before_string;
  2006                 }
  2007             }
  2008 
  2009           *x = top_x;
  2010           /* The condition below is a heuristic fix for the situation
  2011              where move_it_to stops just after finishing the display
  2012              of a fringe bitmap, which resets it.ascent to zero, and
  2013              thus causes Y to be offset by it.max_ascent.  */
  2014           if (it.ascent == 0 && it.what == IT_IMAGE
  2015               && it.method != GET_FROM_IMAGE
  2016               && it.image_id < 0
  2017               && it.max_ascent > 0)
  2018             *y = max (top_y, window_top_y);
  2019           else
  2020             *y = max (top_y + max (0, it.max_ascent - it.ascent), window_top_y);
  2021           *rtop = max (0, window_top_y - top_y);
  2022           *rbot = max (0, bottom_y - it.last_visible_y);
  2023           *rowh = max (0, (min (bottom_y, it.last_visible_y)
  2024                            - max (top_y, window_top_y)));
  2025           *vpos = it.vpos;
  2026           if (it.bidi_it.paragraph_dir == R2L)
  2027             r2l = true;
  2028         }
  2029     }
  2030   else
  2031     {
  2032       /* Either we were asked to provide info about WINDOW_END, or
  2033          CHARPOS is in the partially visible glyph row at end of
  2034          window.  */
  2035       struct it it2;
  2036       void *it2data = NULL;
  2037 
  2038       SAVE_IT (it2, it, it2data);
  2039       if (IT_CHARPOS (it) < ZV && FETCH_BYTE (IT_BYTEPOS (it)) != '\n')
  2040         move_it_by_lines (&it, 1);
  2041       if (charpos < IT_CHARPOS (it)
  2042           || (it.what == IT_EOB && charpos == IT_CHARPOS (it)))
  2043         {
  2044           visible_p = true;
  2045           RESTORE_IT (&it2, &it2, it2data);
  2046           move_it_to (&it2, charpos, -1, -1, -1, MOVE_TO_POS);
  2047           *x = it2.current_x;
  2048           if (it2.ascent == 0 && it2.what == IT_IMAGE
  2049               && it2.method != GET_FROM_IMAGE
  2050               && it2.image_id < 0
  2051               && it2.max_ascent > 0)
  2052             *y = it2.current_y;
  2053           else
  2054             *y = it2.current_y + it2.max_ascent - it2.ascent;
  2055           *rtop = max (0, -it2.current_y);
  2056           *rbot = max (0, ((it2.current_y + it2.max_ascent + it2.max_descent)
  2057                            - it.last_visible_y));
  2058           *rowh = max (0, (min (it2.current_y + it2.max_ascent + it2.max_descent,
  2059                                 it.last_visible_y)
  2060                            - max (max (it2.current_y,
  2061                                        WINDOW_TAB_LINE_HEIGHT (w)),
  2062                                   WINDOW_HEADER_LINE_HEIGHT (w))));
  2063           *vpos = it2.vpos;
  2064           if (it2.bidi_it.paragraph_dir == R2L)
  2065             r2l = true;
  2066         }
  2067       else
  2068         bidi_unshelve_cache (it2data, true);
  2069     }
  2070   bidi_unshelve_cache (itdata, false);
  2071 
  2072   if (old_buffer)
  2073     set_buffer_internal_1 (old_buffer);
  2074 
  2075   if (visible_p)
  2076     {
  2077       if (w->hscroll > 0)
  2078         *x -=
  2079           window_hscroll_limited (w, WINDOW_XFRAME (w))
  2080           * WINDOW_FRAME_COLUMN_WIDTH (w);
  2081       /* For lines in an R2L paragraph, we need to mirror the X pixel
  2082          coordinate wrt the text area.  For the reasons, see the
  2083          commentary in buffer_posn_from_coords and the explanation of
  2084          the geometry used by the move_it_* functions at the end of
  2085          the large commentary near the beginning of this file.  */
  2086       if (r2l)
  2087         *x = window_box_width (w, TEXT_AREA) - *x - 1;
  2088     }
  2089 
  2090 #if false
  2091   /* Debugging code.  */
  2092   if (visible_p)
  2093     fprintf (stderr, "+pv pt=%d vs=%d --> x=%d y=%d rt=%d rb=%d rh=%d vp=%d\n",
  2094              charpos, w->vscroll, *x, *y, *rtop, *rbot, *rowh, *vpos);
  2095   else
  2096     fprintf (stderr, "-pv pt=%d vs=%d\n", charpos, w->vscroll);
  2097 #endif
  2098 
  2099   /* Restore potentially overwritten values.  */
  2100   w->mode_line_height = prev_mode_line_height;
  2101   w->header_line_height = prev_header_line_height;
  2102   w->tab_line_height = prev_tab_line_height;
  2103 
  2104   return visible_p;
  2105 }
  2106 
  2107 
  2108 /* Return the next character from STR.  Return in *LEN the length of
  2109    the character.  This is like string_char_and_length but never
  2110    returns an invalid character.  If we find one, we return a `?', but
  2111    with the length of the invalid character.  */
  2112 
  2113 static int
  2114 check_char_and_length (const unsigned char *str, int *len)
  2115 {
  2116   int c = string_char_and_length (str, len);
  2117   if (!CHAR_VALID_P (c))
  2118     /* We may not change the length here because other places in Emacs
  2119        don't use this function, i.e. they silently accept invalid
  2120        characters.  */
  2121     c = '?';
  2122 
  2123   return c;
  2124 }
  2125 
  2126 
  2127 
  2128 /* Given a position POS containing a valid character and byte position
  2129    in STRING, return the position NCHARS ahead (NCHARS >= 0).  */
  2130 
  2131 static struct text_pos
  2132 string_pos_nchars_ahead (struct text_pos pos, Lisp_Object string, ptrdiff_t nchars)
  2133 {
  2134   eassert (STRINGP (string) && nchars >= 0);
  2135 
  2136   if (STRING_MULTIBYTE (string))
  2137     {
  2138       const unsigned char *p = SDATA (string) + BYTEPOS (pos);
  2139 
  2140       while (nchars--)
  2141         {
  2142           int len = BYTES_BY_CHAR_HEAD (*p);
  2143           p += len;
  2144           CHARPOS (pos) += 1;
  2145           BYTEPOS (pos) += len;
  2146         }
  2147     }
  2148   else
  2149     SET_TEXT_POS (pos, CHARPOS (pos) + nchars, BYTEPOS (pos) + nchars);
  2150 
  2151   return pos;
  2152 }
  2153 
  2154 
  2155 /* Value is the text position, i.e. character and byte position,
  2156    for character position CHARPOS in STRING.  */
  2157 
  2158 static struct text_pos
  2159 string_pos (ptrdiff_t charpos, Lisp_Object string)
  2160 {
  2161   struct text_pos pos;
  2162   eassert (STRINGP (string));
  2163   eassert (charpos >= 0);
  2164   SET_TEXT_POS (pos, charpos, string_char_to_byte (string, charpos));
  2165   return pos;
  2166 }
  2167 
  2168 
  2169 /* Value is a text position, i.e. character and byte position, for
  2170    character position CHARPOS in C string S.  MULTIBYTE_P
  2171    means recognize multibyte characters.  */
  2172 
  2173 static struct text_pos
  2174 c_string_pos (ptrdiff_t charpos, const char *s, bool multibyte_p)
  2175 {
  2176   struct text_pos pos;
  2177 
  2178   eassert (s != NULL);
  2179   eassert (charpos >= 0);
  2180 
  2181   if (multibyte_p)
  2182     {
  2183       SET_TEXT_POS (pos, 0, 0);
  2184       while (charpos--)
  2185         {
  2186           int len = BYTES_BY_CHAR_HEAD (*s);
  2187           s += len;
  2188           CHARPOS (pos) += 1;
  2189           BYTEPOS (pos) += len;
  2190         }
  2191     }
  2192   else
  2193     SET_TEXT_POS (pos, charpos, charpos);
  2194 
  2195   return pos;
  2196 }
  2197 
  2198 
  2199 /* Value is the number of characters in C string S.  MULTIBYTE_P
  2200    means recognize multibyte characters.  */
  2201 
  2202 static ptrdiff_t
  2203 number_of_chars (const char *s, bool multibyte_p)
  2204 {
  2205   ptrdiff_t nchars;
  2206 
  2207   if (multibyte_p)
  2208     {
  2209       ptrdiff_t rest = strlen (s);
  2210       const unsigned char *p = (const unsigned char *) s;
  2211 
  2212       for (nchars = 0; rest > 0; ++nchars)
  2213         {
  2214           int len = BYTES_BY_CHAR_HEAD (*p);
  2215           rest -= len, p += len;
  2216         }
  2217     }
  2218   else
  2219     nchars = strlen (s);
  2220 
  2221   return nchars;
  2222 }
  2223 
  2224 
  2225 /* Compute byte position NEWPOS->bytepos corresponding to
  2226    NEWPOS->charpos.  POS is a known position in string STRING.
  2227    NEWPOS->charpos must be >= POS.charpos.  */
  2228 
  2229 static void
  2230 compute_string_pos (struct text_pos *newpos, struct text_pos pos, Lisp_Object string)
  2231 {
  2232   eassert (STRINGP (string));
  2233   eassert (CHARPOS (*newpos) >= CHARPOS (pos));
  2234 
  2235   if (STRING_MULTIBYTE (string))
  2236     *newpos = string_pos_nchars_ahead (pos, string,
  2237                                        CHARPOS (*newpos) - CHARPOS (pos));
  2238   else
  2239     BYTEPOS (*newpos) = CHARPOS (*newpos);
  2240 }
  2241 
  2242 /* EXPORT:
  2243    Return an estimation of the pixel height of mode or header lines on
  2244    frame F.  FACE_ID specifies what line's height to estimate.  */
  2245 
  2246 int
  2247 estimate_mode_line_height (struct frame *f, enum face_id face_id)
  2248 {
  2249 #ifdef HAVE_WINDOW_SYSTEM
  2250   if (FRAME_WINDOW_P (f))
  2251     {
  2252       int height = FONT_HEIGHT (FRAME_FONT (f));
  2253 
  2254       /* This function is called so early when Emacs starts that the face
  2255          cache and mode line face are not yet initialized.  */
  2256       if (FRAME_FACE_CACHE (f))
  2257         {
  2258           struct face *face = FACE_FROM_ID_OR_NULL (f, face_id);
  2259           if (face)
  2260             {
  2261               if (face->font)
  2262                 height = normal_char_height (face->font, -1);
  2263               if (face->box_horizontal_line_width > 0)
  2264                 height += 2 * face->box_horizontal_line_width;
  2265             }
  2266         }
  2267 
  2268       return height;
  2269     }
  2270 #endif
  2271 
  2272   return 1;
  2273 }
  2274 
  2275 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
  2276    coordinates in (*X, *Y).  Set *BOUNDS to the rectangle that the
  2277    glyph at X, Y occupies, if BOUNDS != 0.  If NOCLIP, do
  2278    not force the value into range.  */
  2279 
  2280 void
  2281 pixel_to_glyph_coords (struct frame *f, int pix_x, int pix_y, int *x, int *y,
  2282                        NativeRectangle *bounds, bool noclip)
  2283 {
  2284 
  2285 #ifdef HAVE_WINDOW_SYSTEM
  2286   if (FRAME_WINDOW_P (f))
  2287     {
  2288       /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to round down
  2289          even for negative values.  */
  2290       if (pix_x < 0)
  2291         pix_x -= FRAME_COLUMN_WIDTH (f) - 1;
  2292       if (pix_y < 0)
  2293         pix_y -= FRAME_LINE_HEIGHT (f) - 1;
  2294 
  2295       pix_x = FRAME_PIXEL_X_TO_COL (f, pix_x);
  2296       pix_y = FRAME_PIXEL_Y_TO_LINE (f, pix_y);
  2297 
  2298       if (bounds)
  2299         STORE_NATIVE_RECT (*bounds,
  2300                            FRAME_COL_TO_PIXEL_X (f, pix_x),
  2301                            FRAME_LINE_TO_PIXEL_Y (f, pix_y),
  2302                            FRAME_COLUMN_WIDTH (f) - 1,
  2303                            FRAME_LINE_HEIGHT (f) - 1);
  2304 
  2305       /* PXW: Should we clip pixels before converting to columns/lines?  */
  2306       if (!noclip)
  2307         {
  2308           if (pix_x < 0)
  2309             pix_x = 0;
  2310           else if (pix_x > FRAME_TOTAL_COLS (f))
  2311             pix_x = FRAME_TOTAL_COLS (f);
  2312 
  2313           if (pix_y < 0)
  2314             pix_y = 0;
  2315           else if (pix_y > FRAME_TOTAL_LINES (f))
  2316             pix_y = FRAME_TOTAL_LINES (f);
  2317         }
  2318     }
  2319 #endif
  2320 
  2321   *x = pix_x;
  2322   *y = pix_y;
  2323 }
  2324 
  2325 
  2326 /* Find the glyph under window-relative coordinates X/Y in window W.
  2327    Consider only glyphs from buffer text, i.e. no glyphs from overlay
  2328    strings.  Return in *HPOS and *VPOS the row and column number of
  2329    the glyph found.  Return in *AREA the glyph area containing X.
  2330    Value is a pointer to the glyph found or null if X/Y is not on
  2331    text, or we can't tell because W's current matrix is not up to
  2332    date.  */
  2333 
  2334 struct glyph *
  2335 x_y_to_hpos_vpos (struct window *w, int x, int y, int *hpos, int *vpos,
  2336                   int *dx, int *dy, int *area)
  2337 {
  2338   struct glyph *glyph, *end;
  2339   struct glyph_row *row = NULL;
  2340   int x0, i;
  2341 
  2342   /* Find row containing Y.  Give up if some row is not enabled.  */
  2343   for (i = 0; i < w->current_matrix->nrows; ++i)
  2344     {
  2345       row = MATRIX_ROW (w->current_matrix, i);
  2346       if (!row->enabled_p)
  2347         return NULL;
  2348       if (y >= row->y && y < MATRIX_ROW_BOTTOM_Y (row))
  2349         break;
  2350     }
  2351 
  2352   *vpos = i;
  2353   *hpos = 0;
  2354 
  2355   /* Give up if Y is not in the window.  */
  2356   if (i == w->current_matrix->nrows)
  2357     return NULL;
  2358 
  2359   /* Get the glyph area containing X.  */
  2360   if (w->pseudo_window_p)
  2361     {
  2362       *area = TEXT_AREA;
  2363       x0 = 0;
  2364     }
  2365   else
  2366     {
  2367       if (x < window_box_left_offset (w, TEXT_AREA))
  2368         {
  2369           *area = LEFT_MARGIN_AREA;
  2370           x0 = window_box_left_offset (w, LEFT_MARGIN_AREA);
  2371         }
  2372       else if (x < window_box_right_offset (w, TEXT_AREA))
  2373         {
  2374           *area = TEXT_AREA;
  2375           x0 = window_box_left_offset (w, TEXT_AREA) + min (row->x, 0);
  2376         }
  2377       else
  2378         {
  2379           *area = RIGHT_MARGIN_AREA;
  2380           x0 = window_box_left_offset (w, RIGHT_MARGIN_AREA);
  2381         }
  2382     }
  2383 
  2384   /* Find glyph containing X.  */
  2385   glyph = row->glyphs[*area];
  2386   end = glyph + row->used[*area];
  2387   x -= x0;
  2388   while (glyph < end && x >= glyph->pixel_width)
  2389     {
  2390       x -= glyph->pixel_width;
  2391       ++glyph;
  2392     }
  2393 
  2394   if (glyph == end)
  2395     return NULL;
  2396 
  2397   if (dx)
  2398     {
  2399       *dx = x;
  2400       *dy = y - (row->y + row->ascent - glyph->ascent);
  2401     }
  2402 
  2403   *hpos = glyph - row->glyphs[*area];
  2404   return glyph;
  2405 }
  2406 
  2407 /* Convert frame-relative x/y to coordinates relative to window W.
  2408    Takes pseudo-windows into account.  */
  2409 
  2410 static void
  2411 frame_to_window_pixel_xy (struct window *w, int *x, int *y)
  2412 {
  2413   if (w->pseudo_window_p)
  2414     {
  2415       /* A pseudo-window is always full-width, and starts at the
  2416          left edge of the frame, plus a frame border.  */
  2417       struct frame *f = XFRAME (w->frame);
  2418       *x -= FRAME_INTERNAL_BORDER_WIDTH (f);
  2419       *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
  2420     }
  2421   else
  2422     {
  2423       *x -= WINDOW_LEFT_EDGE_X (w);
  2424       *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
  2425     }
  2426 }
  2427 
  2428 #ifdef HAVE_WINDOW_SYSTEM
  2429 
  2430 /* EXPORT:
  2431    Return in RECTS[] at most N clipping rectangles for glyph string S.
  2432    Return the number of stored rectangles.  */
  2433 
  2434 int
  2435 get_glyph_string_clip_rects (struct glyph_string *s, NativeRectangle *rects, int n)
  2436 {
  2437   Emacs_Rectangle r;
  2438 
  2439   if (n <= 0)
  2440     return 0;
  2441 
  2442   if (s->row->full_width_p)
  2443     {
  2444       /* Draw full-width.  X coordinates are relative to S->w->left_col.  */
  2445       r.x = WINDOW_LEFT_EDGE_X (s->w);
  2446       if (s->row->mode_line_p)
  2447         r.width = WINDOW_PIXEL_WIDTH (s->w) - WINDOW_RIGHT_DIVIDER_WIDTH (s->w);
  2448       else
  2449         r.width = WINDOW_PIXEL_WIDTH (s->w);
  2450 
  2451       /* Unless displaying a mode or menu bar line, which are always
  2452          fully visible, clip to the visible part of the row.  */
  2453       if (s->w->pseudo_window_p)
  2454         r.height = s->row->visible_height;
  2455       else
  2456         r.height = s->height;
  2457     }
  2458   else
  2459     {
  2460       /* This is a text line that may be partially visible.  */
  2461       r.x = window_box_left (s->w, s->area);
  2462       r.width = window_box_width (s->w, s->area);
  2463       r.height = s->row->visible_height;
  2464     }
  2465 
  2466   if (s->clip_head)
  2467     if (r.x < s->clip_head->x)
  2468       {
  2469         if (r.width >= s->clip_head->x - r.x)
  2470           r.width -= s->clip_head->x - r.x;
  2471         else
  2472           r.width = 0;
  2473         r.x = s->clip_head->x;
  2474       }
  2475   if (s->clip_tail)
  2476     if (r.x + r.width > s->clip_tail->x + s->clip_tail->background_width)
  2477       {
  2478         if (s->clip_tail->x + s->clip_tail->background_width >= r.x)
  2479           r.width = s->clip_tail->x + s->clip_tail->background_width - r.x;
  2480         else
  2481           r.width = 0;
  2482       }
  2483 
  2484   /* If S draws overlapping rows, it's sufficient to use the top and
  2485      bottom of the window for clipping because this glyph string
  2486      intentionally draws over other lines.  */
  2487   if (s->for_overlaps)
  2488     {
  2489       r.y = WINDOW_TAB_LINE_HEIGHT (s->w) + WINDOW_HEADER_LINE_HEIGHT (s->w);
  2490       r.height = window_text_bottom_y (s->w) - r.y;
  2491 
  2492       /* Alas, the above simple strategy does not work for the
  2493          environments with anti-aliased text: if the same text is
  2494          drawn onto the same place multiple times, it gets thicker.
  2495          If the overlap we are processing is for the erased cursor, we
  2496          take the intersection with the rectangle of the cursor.  */
  2497       if (s->for_overlaps & OVERLAPS_ERASED_CURSOR)
  2498         {
  2499           Emacs_Rectangle rc, r_save = r;
  2500 
  2501           rc.x = WINDOW_TEXT_TO_FRAME_PIXEL_X (s->w, s->w->phys_cursor.x);
  2502           rc.y = s->w->phys_cursor.y;
  2503           rc.width = s->w->phys_cursor_width;
  2504           rc.height = s->w->phys_cursor_height;
  2505 
  2506           gui_intersect_rectangles (&r_save, &rc, &r);
  2507         }
  2508     }
  2509   else
  2510     {
  2511       /* Don't use S->y for clipping because it doesn't take partially
  2512          visible lines into account.  For example, it can be negative for
  2513          partially visible lines at the top of a window.  */
  2514       if (!s->row->full_width_p
  2515           && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s->w, s->row))
  2516         r.y = WINDOW_TAB_LINE_HEIGHT (s->w) + WINDOW_HEADER_LINE_HEIGHT (s->w);
  2517       else
  2518         r.y = max (0, s->row->y);
  2519     }
  2520 
  2521   r.y = WINDOW_TO_FRAME_PIXEL_Y (s->w, r.y);
  2522 
  2523   /* If drawing the cursor, don't let glyph draw outside its
  2524      advertised boundaries. Cleartype does this under some circumstances.  */
  2525   if (s->hl == DRAW_CURSOR)
  2526     {
  2527       struct glyph *glyph = s->first_glyph;
  2528       int height, max_y;
  2529 
  2530       if (s->x > r.x)
  2531         {
  2532           if (r.width >= s->x - r.x)
  2533             r.width -= s->x - r.x;
  2534           else  /* R2L hscrolled row with cursor outside text area */
  2535             r.width = 0;
  2536           r.x = s->x;
  2537         }
  2538       r.width = min (r.width, glyph->pixel_width);
  2539 
  2540       /* If r.y is below window bottom, ensure that we still see a cursor.  */
  2541       height = min (glyph->ascent + glyph->descent,
  2542                     min (FRAME_LINE_HEIGHT (s->f), s->row->visible_height));
  2543       max_y = window_text_bottom_y (s->w) - height;
  2544       max_y = WINDOW_TO_FRAME_PIXEL_Y (s->w, max_y);
  2545       if (s->ybase - glyph->ascent > max_y)
  2546         {
  2547           r.y = max_y;
  2548           r.height = height;
  2549         }
  2550       else
  2551         {
  2552           /* Don't draw cursor glyph taller than our actual glyph.  */
  2553           height = max (FRAME_LINE_HEIGHT (s->f), glyph->ascent + glyph->descent);
  2554           if (height < r.height)
  2555             {
  2556               max_y = r.y + r.height;
  2557               r.y = min (max_y, max (r.y, s->ybase + glyph->descent - height));
  2558               r.height = min (max_y - r.y, height);
  2559             }
  2560         }
  2561     }
  2562 
  2563   if (s->row->clip)
  2564     {
  2565       Emacs_Rectangle r_save = r;
  2566 
  2567       if (! gui_intersect_rectangles (&r_save, s->row->clip, &r))
  2568         r.width = 0;
  2569     }
  2570 
  2571   if ((s->for_overlaps & OVERLAPS_BOTH) == 0
  2572       || ((s->for_overlaps & OVERLAPS_BOTH) == OVERLAPS_BOTH && n == 1))
  2573     {
  2574 #ifdef CONVERT_FROM_EMACS_RECT
  2575       CONVERT_FROM_EMACS_RECT (r, *rects);
  2576 #else
  2577       *rects = r;
  2578 #endif
  2579       return 1;
  2580     }
  2581   else
  2582     {
  2583       /* If we are processing overlapping and allowed to return
  2584          multiple clipping rectangles, we exclude the row of the glyph
  2585          string from the clipping rectangle.  This is to avoid drawing
  2586          the same text on the environment with anti-aliasing.  */
  2587 #ifdef CONVERT_FROM_EMACS_RECT
  2588       Emacs_Rectangle rs[2];
  2589 #else
  2590       Emacs_Rectangle *rs = rects;
  2591 #endif
  2592       int i = 0, row_y = WINDOW_TO_FRAME_PIXEL_Y (s->w, s->row->y);
  2593 
  2594       if (s->for_overlaps & OVERLAPS_PRED)
  2595         {
  2596           rs[i] = r;
  2597           if (r.y + r.height > row_y)
  2598             {
  2599               if (r.y < row_y)
  2600                 rs[i].height = row_y - r.y;
  2601               else
  2602                 rs[i].height = 0;
  2603             }
  2604           i++;
  2605         }
  2606       if (s->for_overlaps & OVERLAPS_SUCC)
  2607         {
  2608           rs[i] = r;
  2609           if (r.y < row_y + s->row->visible_height)
  2610             {
  2611               if (r.y + r.height > row_y + s->row->visible_height)
  2612                 {
  2613                   rs[i].y = row_y + s->row->visible_height;
  2614                   rs[i].height = r.y + r.height - rs[i].y;
  2615                 }
  2616               else
  2617                 rs[i].height = 0;
  2618             }
  2619           i++;
  2620         }
  2621 
  2622       n = i;
  2623 #ifdef CONVERT_FROM_EMACS_RECT
  2624       for (i = 0; i < n; i++)
  2625         CONVERT_FROM_EMACS_RECT (rs[i], rects[i]);
  2626 #endif
  2627       return n;
  2628     }
  2629 }
  2630 
  2631 /* EXPORT:
  2632    Return in *NR the clipping rectangle for glyph string S.  */
  2633 
  2634 void
  2635 get_glyph_string_clip_rect (struct glyph_string *s, NativeRectangle *nr)
  2636 {
  2637   get_glyph_string_clip_rects (s, nr, 1);
  2638 }
  2639 
  2640 
  2641 /* EXPORT:
  2642    Return the position and height of the phys cursor in window W.
  2643    Set w->phys_cursor_width to width of phys cursor.
  2644 */
  2645 
  2646 void
  2647 get_phys_cursor_geometry (struct window *w, struct glyph_row *row,
  2648                           struct glyph *glyph, int *xp, int *yp, int *heightp)
  2649 {
  2650   struct frame *f = XFRAME (WINDOW_FRAME (w));
  2651   int x, y, wd, h, h0, y0, ascent;
  2652 
  2653   /* Compute the width of the rectangle to draw.  If on a stretch
  2654      glyph, and `x-stretch-cursor' is nil, don't draw a rectangle
  2655      as wide as the glyph, but use a canonical character width
  2656      instead.  */
  2657   wd = glyph->pixel_width;
  2658 
  2659   x = w->phys_cursor.x;
  2660   if (x < 0)
  2661     {
  2662       wd += x;
  2663       x = 0;
  2664     }
  2665 
  2666   if (glyph->type == STRETCH_GLYPH
  2667       && !x_stretch_cursor_p)
  2668     wd = min (FRAME_COLUMN_WIDTH (f), wd);
  2669   w->phys_cursor_width = wd;
  2670 
  2671   /* Don't let the hollow cursor glyph descend below the glyph row's
  2672      ascent value, lest the hollow cursor looks funny.  */
  2673   y = w->phys_cursor.y;
  2674   ascent = row->ascent;
  2675   /* The test for row at ZV is for when line numbers are displayed and
  2676      point is at EOB: the cursor could then be smaller or larger than
  2677      the default face's font.  */
  2678   if (!row->ends_at_zv_p && row->ascent < glyph->ascent)
  2679     {
  2680       y -= glyph->ascent - row->ascent;
  2681       ascent = glyph->ascent;
  2682     }
  2683 
  2684   /* If y is below window bottom, ensure that we still see a cursor.  */
  2685   h0 = min (FRAME_LINE_HEIGHT (f), row->visible_height);
  2686 
  2687   h = max (h0, ascent + glyph->descent);
  2688   /* Don't let the cursor exceed the dimensions of the row, so that
  2689      the upper/lower side of the box aren't clipped.  */
  2690   h = min (h, row->height);
  2691   h0 = min (h0, ascent + glyph->descent);
  2692 
  2693   y0 = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
  2694   if (y < y0)
  2695     {
  2696       h = max (h - (y0 - y) + 1, h0);
  2697       y = y0 - 1;
  2698     }
  2699   else
  2700     {
  2701       y0 = window_text_bottom_y (w) - h0;
  2702       if (y > y0)
  2703         {
  2704           h += y - y0;
  2705           y = y0;
  2706         }
  2707     }
  2708 
  2709   *xp = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, x);
  2710   *yp = WINDOW_TO_FRAME_PIXEL_Y (w, y);
  2711   *heightp = h;
  2712 }
  2713 
  2714 /*
  2715  * Remember which glyph the mouse is over.
  2716  */
  2717 
  2718 void
  2719 remember_mouse_glyph (struct frame *f, int gx, int gy, NativeRectangle *rect)
  2720 {
  2721   Lisp_Object window;
  2722   struct window *w;
  2723   struct glyph_row *r, *gr, *end_row;
  2724   enum window_part part;
  2725   enum glyph_row_area area;
  2726   int x, y, width, height;
  2727 
  2728   if (mouse_fine_grained_tracking)
  2729     {
  2730       STORE_NATIVE_RECT (*rect, gx, gy, 1, 1);
  2731       return;
  2732     }
  2733 
  2734   /* Try to determine frame pixel position and size of the glyph under
  2735      frame pixel coordinates X/Y on frame F.  */
  2736 
  2737   if (window_resize_pixelwise)
  2738     {
  2739       width = height = 1;
  2740       goto virtual_glyph;
  2741     }
  2742   else if (!f->glyphs_initialized_p
  2743            || (window = window_from_coordinates (f, gx, gy, &part, false, false),
  2744                NILP (window)))
  2745     {
  2746       width = FRAME_SMALLEST_CHAR_WIDTH (f);
  2747       height = FRAME_SMALLEST_FONT_HEIGHT (f);
  2748       goto virtual_glyph;
  2749     }
  2750 
  2751   w = XWINDOW (window);
  2752   width = WINDOW_FRAME_COLUMN_WIDTH (w);
  2753   height = WINDOW_FRAME_LINE_HEIGHT (w);
  2754 
  2755   x = window_relative_x_coord (w, part, gx);
  2756   y = gy - WINDOW_TOP_EDGE_Y (w);
  2757 
  2758   r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
  2759   end_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
  2760 
  2761   if (w->pseudo_window_p)
  2762     {
  2763       area = TEXT_AREA;
  2764       part = ON_MODE_LINE; /* Don't adjust margin. */
  2765       goto text_glyph;
  2766     }
  2767 
  2768   switch (part)
  2769     {
  2770     case ON_LEFT_MARGIN:
  2771       area = LEFT_MARGIN_AREA;
  2772       goto text_glyph;
  2773 
  2774     case ON_RIGHT_MARGIN:
  2775       area = RIGHT_MARGIN_AREA;
  2776       goto text_glyph;
  2777 
  2778     case ON_TAB_LINE:
  2779     case ON_HEADER_LINE:
  2780     case ON_MODE_LINE:
  2781       gr = (part == ON_TAB_LINE
  2782             ? MATRIX_TAB_LINE_ROW (w->current_matrix)
  2783             : (part == ON_HEADER_LINE
  2784                ? MATRIX_HEADER_LINE_ROW (w->current_matrix)
  2785                : MATRIX_MODE_LINE_ROW (w->current_matrix)));
  2786       gy = gr->y;
  2787       area = TEXT_AREA;
  2788       goto text_glyph_row_found;
  2789 
  2790     case ON_TEXT:
  2791       area = TEXT_AREA;
  2792 
  2793     text_glyph:
  2794       gr = 0; gy = 0;
  2795       for (; r <= end_row && r->enabled_p; ++r)
  2796         if (r->y + r->height > y)
  2797           {
  2798             gr = r; gy = r->y;
  2799             break;
  2800           }
  2801 
  2802     text_glyph_row_found:
  2803       if (gr && gy <= y)
  2804         {
  2805           struct glyph *g = gr->glyphs[area];
  2806           struct glyph *end = g + gr->used[area];
  2807 
  2808           height = gr->height;
  2809           for (gx = gr->x; g < end; gx += g->pixel_width, ++g)
  2810             if (gx + g->pixel_width > x)
  2811               break;
  2812 
  2813           if (g < end)
  2814             {
  2815               if (g->type == IMAGE_GLYPH)
  2816                 {
  2817                   /* Don't remember when mouse is over image, as
  2818                      image may have hot-spots.  */
  2819                   STORE_NATIVE_RECT (*rect, 0, 0, 0, 0);
  2820                   return;
  2821                 }
  2822               width = g->pixel_width;
  2823             }
  2824           else
  2825             {
  2826               /* Use nominal char spacing at end of line.  */
  2827               x -= gx;
  2828               gx += (x / width) * width;
  2829             }
  2830 
  2831           if (part != ON_MODE_LINE && part != ON_HEADER_LINE
  2832               && part != ON_TAB_LINE)
  2833             {
  2834               gx += window_box_left_offset (w, area);
  2835               /* Don't expand over the modeline to make sure the vertical
  2836                  drag cursor is shown early enough.  */
  2837               height = min (height,
  2838                             max (0, WINDOW_BOX_HEIGHT_NO_MODE_LINE (w) - gy));
  2839             }
  2840         }
  2841       else
  2842         {
  2843           /* Use nominal line height at end of window.  */
  2844           gx = (x / width) * width;
  2845           y -= gy;
  2846           gy += (y / height) * height;
  2847           if (part != ON_MODE_LINE && part != ON_HEADER_LINE
  2848               && part != ON_TAB_LINE)
  2849             /* See comment above.  */
  2850             height = min (height,
  2851                           max (0, WINDOW_BOX_HEIGHT_NO_MODE_LINE (w) - gy));
  2852         }
  2853       break;
  2854 
  2855     case ON_LEFT_FRINGE:
  2856       gx = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
  2857             ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w)
  2858             : window_box_right_offset (w, LEFT_MARGIN_AREA));
  2859       width = WINDOW_LEFT_FRINGE_WIDTH (w);
  2860       goto row_glyph;
  2861 
  2862     case ON_RIGHT_FRINGE:
  2863       gx = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
  2864             ? window_box_right_offset (w, RIGHT_MARGIN_AREA)
  2865             : window_box_right_offset (w, TEXT_AREA));
  2866       if (WINDOW_RIGHT_DIVIDER_WIDTH (w) == 0
  2867           && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w)
  2868           && !WINDOW_RIGHTMOST_P (w))
  2869         if (gx < WINDOW_PIXEL_WIDTH (w) - width)
  2870           /* Make sure the vertical border can get her own glyph to the
  2871              right of the one we build here.  */
  2872           width = WINDOW_RIGHT_FRINGE_WIDTH (w) - width;
  2873         else
  2874           width = WINDOW_PIXEL_WIDTH (w) - gx;
  2875       else
  2876         width = WINDOW_RIGHT_FRINGE_WIDTH (w);
  2877 
  2878       goto row_glyph;
  2879 
  2880     case ON_VERTICAL_BORDER:
  2881       gx = WINDOW_PIXEL_WIDTH (w) - width;
  2882       goto row_glyph;
  2883 
  2884     case ON_VERTICAL_SCROLL_BAR:
  2885       gx = (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)
  2886             ? 0
  2887             : (window_box_right_offset (w, RIGHT_MARGIN_AREA)
  2888                + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
  2889                   ? WINDOW_RIGHT_FRINGE_WIDTH (w)
  2890                   : 0)));
  2891       width = WINDOW_SCROLL_BAR_AREA_WIDTH (w);
  2892 
  2893     row_glyph:
  2894       gr = 0, gy = 0;
  2895       for (; r <= end_row && r->enabled_p; ++r)
  2896         if (r->y + r->height > y)
  2897           {
  2898             gr = r; gy = r->y;
  2899             break;
  2900           }
  2901 
  2902       if (gr && gy <= y)
  2903         height = gr->height;
  2904       else
  2905         {
  2906           /* Use nominal line height at end of window.  */
  2907           y -= gy;
  2908           gy += (y / height) * height;
  2909         }
  2910       break;
  2911 
  2912     case ON_RIGHT_DIVIDER:
  2913       gx = WINDOW_PIXEL_WIDTH (w) - WINDOW_RIGHT_DIVIDER_WIDTH (w);
  2914       width = WINDOW_RIGHT_DIVIDER_WIDTH (w);
  2915       gy = 0;
  2916       /* The bottom divider prevails. */
  2917       height = WINDOW_PIXEL_HEIGHT (w) - WINDOW_BOTTOM_DIVIDER_WIDTH (w);
  2918       goto add_edge;
  2919 
  2920     case ON_BOTTOM_DIVIDER:
  2921       gx = 0;
  2922       width = WINDOW_PIXEL_WIDTH (w);
  2923       gy = WINDOW_PIXEL_HEIGHT (w) - WINDOW_BOTTOM_DIVIDER_WIDTH (w);
  2924       height = WINDOW_BOTTOM_DIVIDER_WIDTH (w);
  2925       goto add_edge;
  2926 
  2927     default:
  2928       ;
  2929     virtual_glyph:
  2930       /* If there is no glyph under the mouse, then we divide the screen
  2931          into a grid of the smallest glyph in the frame, and use that
  2932          as our "glyph".  */
  2933 
  2934       /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
  2935          round down even for negative values.  */
  2936       if (gx < 0)
  2937         gx -= width - 1;
  2938       if (gy < 0)
  2939         gy -= height - 1;
  2940 
  2941       gx = (gx / width) * width;
  2942       gy = (gy / height) * height;
  2943 
  2944       goto store_rect;
  2945     }
  2946 
  2947  add_edge:
  2948   gx += WINDOW_LEFT_EDGE_X (w);
  2949   gy += WINDOW_TOP_EDGE_Y (w);
  2950 
  2951  store_rect:
  2952   STORE_NATIVE_RECT (*rect, gx, gy, width, height);
  2953 
  2954   /* Visible feedback for debugging.  */
  2955 #if false && defined HAVE_X_WINDOWS
  2956   XDrawRectangle (FRAME_X_DISPLAY (f), FRAME_X_DRAWABLE (f),
  2957                   f->output_data.x->normal_gc,
  2958                   gx, gy, width, height);
  2959 #endif
  2960 }
  2961 
  2962 
  2963 #endif /* HAVE_WINDOW_SYSTEM */
  2964 
  2965 static void
  2966 adjust_window_ends (struct window *w, struct glyph_row *row, bool current)
  2967 {
  2968   eassert (w);
  2969   w->window_end_pos = Z - MATRIX_ROW_END_CHARPOS (row);
  2970   w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
  2971   w->window_end_vpos
  2972     = MATRIX_ROW_VPOS (row, current ? w->current_matrix : w->desired_matrix);
  2973 }
  2974 
  2975 static bool
  2976 hscrolling_current_line_p (struct window *w)
  2977 {
  2978   return (!w->suspend_auto_hscroll
  2979           && EQ (Fbuffer_local_value (Qauto_hscroll_mode, w->contents),
  2980                  Qcurrent_line));
  2981 }
  2982 
  2983 /***********************************************************************
  2984                         Lisp form evaluation
  2985  ***********************************************************************/
  2986 
  2987 /* Error handler for safe_eval and safe_call.  */
  2988 
  2989 static Lisp_Object
  2990 safe_eval_handler (Lisp_Object arg, ptrdiff_t nargs, Lisp_Object *args)
  2991 {
  2992   add_to_log ("Error during redisplay: %S signaled %S",
  2993               Flist (nargs, args), arg);
  2994   return Qnil;
  2995 }
  2996 
  2997 /* Call function FUNC with the rest of NARGS - 1 arguments
  2998    following.  Return the result, or nil if something went
  2999    wrong.  Prevent redisplay during the evaluation.  */
  3000 
  3001 static Lisp_Object
  3002 safe__call (bool inhibit_quit, ptrdiff_t nargs, Lisp_Object func, va_list ap)
  3003 {
  3004   Lisp_Object val;
  3005 
  3006   if (inhibit_eval_during_redisplay)
  3007     val = Qnil;
  3008   else
  3009     {
  3010       ptrdiff_t i;
  3011       specpdl_ref count = SPECPDL_INDEX ();
  3012       Lisp_Object *args;
  3013       USE_SAFE_ALLOCA;
  3014       SAFE_ALLOCA_LISP (args, nargs);
  3015 
  3016       args[0] = func;
  3017       for (i = 1; i < nargs; i++)
  3018         args[i] = va_arg (ap, Lisp_Object);
  3019 
  3020       specbind (Qinhibit_redisplay, Qt);
  3021       if (inhibit_quit)
  3022         specbind (Qinhibit_quit, Qt);
  3023       /* Use Qt to ensure debugger does not run,
  3024          so there is no possibility of wanting to redisplay.  */
  3025       val = internal_condition_case_n (Ffuncall, nargs, args, Qt,
  3026                                        safe_eval_handler);
  3027       val = SAFE_FREE_UNBIND_TO (count, val);
  3028     }
  3029 
  3030   return val;
  3031 }
  3032 
  3033 Lisp_Object
  3034 safe_call (ptrdiff_t nargs, Lisp_Object func, ...)
  3035 {
  3036   Lisp_Object retval;
  3037   va_list ap;
  3038 
  3039   va_start (ap, func);
  3040   retval = safe__call (false, nargs, func, ap);
  3041   va_end (ap);
  3042   return retval;
  3043 }
  3044 
  3045 /* Call function FN with one argument ARG.
  3046    Return the result, or nil if something went wrong.  */
  3047 
  3048 Lisp_Object
  3049 safe_call1 (Lisp_Object fn, Lisp_Object arg)
  3050 {
  3051   return safe_call (2, fn, arg);
  3052 }
  3053 
  3054 static Lisp_Object
  3055 safe__call1 (bool inhibit_quit, Lisp_Object fn, ...)
  3056 {
  3057   Lisp_Object retval;
  3058   va_list ap;
  3059 
  3060   va_start (ap, fn);
  3061   retval = safe__call (inhibit_quit, 2, fn, ap);
  3062   va_end (ap);
  3063   return retval;
  3064 }
  3065 
  3066 Lisp_Object
  3067 safe_eval (Lisp_Object sexpr)
  3068 {
  3069   return safe__call1 (false, Qeval, sexpr);
  3070 }
  3071 
  3072 static Lisp_Object
  3073 safe__eval (bool inhibit_quit, Lisp_Object sexpr)
  3074 {
  3075   return safe__call1 (inhibit_quit, Qeval, sexpr);
  3076 }
  3077 
  3078 /* Call function FN with two arguments ARG1 and ARG2.
  3079    Return the result, or nil if something went wrong.  */
  3080 
  3081 Lisp_Object
  3082 safe_call2 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2)
  3083 {
  3084   return safe_call (3, fn, arg1, arg2);
  3085 }
  3086 
  3087 
  3088 
  3089 /***********************************************************************
  3090                               Debugging
  3091  ***********************************************************************/
  3092 
  3093 /* Define CHECK_IT to perform sanity checks on iterators.
  3094    This is for debugging.  It is too slow to do unconditionally.  */
  3095 
  3096 static void
  3097 CHECK_IT (struct it *it)
  3098 {
  3099 #if false
  3100   if (it->method == GET_FROM_STRING)
  3101     {
  3102       eassert (STRINGP (it->string));
  3103       eassert (IT_STRING_CHARPOS (*it) >= 0);
  3104     }
  3105   else
  3106     {
  3107       eassert (IT_STRING_CHARPOS (*it) < 0);
  3108       if (it->method == GET_FROM_BUFFER)
  3109         {
  3110           /* Check that character and byte positions agree.  */
  3111           eassert (IT_CHARPOS (*it) == BYTE_TO_CHAR (IT_BYTEPOS (*it)));
  3112         }
  3113     }
  3114 
  3115   if (it->dpvec)
  3116     eassert (it->current.dpvec_index >= 0);
  3117   else
  3118     eassert (it->current.dpvec_index < 0);
  3119 #endif
  3120 }
  3121 
  3122 
  3123 /* Check that the window end of window W is what we expect it
  3124    to be---the last row in the current matrix displaying text.  */
  3125 
  3126 static void
  3127 CHECK_WINDOW_END (struct window *w)
  3128 {
  3129 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
  3130   if (!MINI_WINDOW_P (w) && w->window_end_valid)
  3131     {
  3132       struct glyph_row *row;
  3133       eassert ((row = MATRIX_ROW (w->current_matrix, w->window_end_vpos),
  3134                 !row->enabled_p
  3135                 || MATRIX_ROW_DISPLAYS_TEXT_P (row)
  3136                 || MATRIX_ROW_VPOS (row, w->current_matrix) == 0));
  3137     }
  3138 #endif
  3139 }
  3140 
  3141 /***********************************************************************
  3142                        Iterator initialization
  3143  ***********************************************************************/
  3144 
  3145 /* Initialize IT for displaying current_buffer in window W, starting
  3146    at character position CHARPOS.  CHARPOS < 0 means that no buffer
  3147    position is specified which is useful when the iterator is assigned
  3148    a position later.  BYTEPOS is the byte position corresponding to
  3149    CHARPOS.
  3150 
  3151    If ROW is not null, calls to produce_glyphs with IT as parameter
  3152    will produce glyphs in that row.
  3153 
  3154    BASE_FACE_ID is the id of a base face to use.  It must be one of
  3155    DEFAULT_FACE_ID for normal text, MODE_LINE_ACTIVE_FACE_ID,
  3156    MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID for displaying
  3157    mode lines, or TOOL_BAR_FACE_ID for displaying the tool-bar.
  3158 
  3159    If ROW is null and BASE_FACE_ID is equal to MODE_LINE_ACTIVE_FACE_ID,
  3160    MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID, the iterator
  3161    will be initialized to use the corresponding mode line glyph row of
  3162    the desired matrix of W.  */
  3163 
  3164 void
  3165 init_iterator (struct it *it, struct window *w,
  3166                ptrdiff_t charpos, ptrdiff_t bytepos,
  3167                struct glyph_row *row, enum face_id base_face_id)
  3168 {
  3169   enum face_id remapped_base_face_id = base_face_id;
  3170   int body_width = 0, body_height = 0;
  3171 
  3172   /* Some precondition checks.  */
  3173   eassert (w != NULL && it != NULL);
  3174   eassert (charpos < 0 || (charpos >= BUF_BEG (current_buffer)
  3175                            && charpos <= ZV));
  3176 
  3177   /* If face attributes have been changed since the last redisplay,
  3178      free realized faces now because they depend on face definitions
  3179      that might have changed.  Don't free faces while there might be
  3180      desired matrices pending which reference these faces.  */
  3181   if (!inhibit_free_realized_faces)
  3182     {
  3183       if (face_change)
  3184         {
  3185           face_change = false;
  3186           XFRAME (w->frame)->face_change = 0;
  3187           free_all_realized_faces (Qnil);
  3188         }
  3189       else if (XFRAME (w->frame)->face_change)
  3190         {
  3191           XFRAME (w->frame)->face_change = 0;
  3192           free_all_realized_faces (w->frame);
  3193         }
  3194     }
  3195 
  3196   /* Perhaps remap BASE_FACE_ID to a user-specified alternative.  */
  3197   if (! NILP (Vface_remapping_alist))
  3198     remapped_base_face_id
  3199       = lookup_basic_face (w, XFRAME (w->frame), base_face_id);
  3200 
  3201   /* Use one of the mode line rows of W's desired matrix if
  3202      appropriate.  */
  3203   if (row == NULL)
  3204     {
  3205       if (base_face_id == MODE_LINE_ACTIVE_FACE_ID
  3206           || base_face_id == MODE_LINE_INACTIVE_FACE_ID)
  3207         row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
  3208       else if (base_face_id == TAB_LINE_FACE_ID)
  3209         row = MATRIX_TAB_LINE_ROW (w->desired_matrix);
  3210       else if (base_face_id == HEADER_LINE_FACE_ID)
  3211         {
  3212           /* Header line row depends on whether tab line is enabled.  */
  3213           w->desired_matrix->tab_line_p = window_wants_tab_line (w);
  3214           row = MATRIX_HEADER_LINE_ROW (w->desired_matrix);
  3215         }
  3216     }
  3217 
  3218   /* Clear IT, and set it->object and other IT's Lisp objects to Qnil.
  3219      Other parts of redisplay rely on that.  */
  3220   memclear (it, sizeof *it);
  3221   it->current.overlay_string_index = -1;
  3222   it->current.dpvec_index = -1;
  3223   it->base_face_id = remapped_base_face_id;
  3224   IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = -1;
  3225   it->paragraph_embedding = L2R;
  3226   it->bidi_it.w = w;
  3227 
  3228   /* The window in which we iterate over current_buffer:  */
  3229   XSETWINDOW (it->window, w);
  3230   it->w = w;
  3231   it->f = XFRAME (w->frame);
  3232 
  3233   it->cmp_it.id = -1;
  3234   it->cmp_it.parent_it = it;
  3235 
  3236   if (max_redisplay_ticks > 0)
  3237     update_redisplay_ticks (0, w);
  3238 
  3239   /* Extra space between lines (on window systems only).  */
  3240   if (base_face_id == DEFAULT_FACE_ID
  3241       && FRAME_WINDOW_P (it->f))
  3242     {
  3243       if (FIXNATP (BVAR (current_buffer, extra_line_spacing)))
  3244         it->extra_line_spacing = XFIXNAT (BVAR (current_buffer, extra_line_spacing));
  3245       else if (FLOATP (BVAR (current_buffer, extra_line_spacing)))
  3246         it->extra_line_spacing = (XFLOAT_DATA (BVAR (current_buffer, extra_line_spacing))
  3247                                   * FRAME_LINE_HEIGHT (it->f));
  3248       else if (it->f->extra_line_spacing > 0)
  3249         it->extra_line_spacing = it->f->extra_line_spacing;
  3250     }
  3251 
  3252   /* If realized faces have been removed, e.g. because of face
  3253      attribute changes of named faces, recompute them.  When running
  3254      in batch mode, the face cache of the initial frame is null.  If
  3255      we happen to get called, make a dummy face cache.  */
  3256   if (FRAME_FACE_CACHE (it->f) == NULL)
  3257     init_frame_faces (it->f);
  3258   if (FRAME_FACE_CACHE (it->f)->used == 0)
  3259     recompute_basic_faces (it->f);
  3260 
  3261   it->override_ascent = -1;
  3262 
  3263   /* Are control characters displayed as `^C'?  */
  3264   it->ctl_arrow_p = !NILP (BVAR (current_buffer, ctl_arrow));
  3265 
  3266   /* -1 means everything between a CR and the following line end
  3267      is invisible.  >0 means lines indented more than this value are
  3268      invisible.  */
  3269   it->selective = (FIXNUMP (BVAR (current_buffer, selective_display))
  3270                    ? (clip_to_bounds
  3271                       (-1, XFIXNUM (BVAR (current_buffer, selective_display)),
  3272                        PTRDIFF_MAX))
  3273                    : (!NILP (BVAR (current_buffer, selective_display))
  3274                       ? -1 : 0));
  3275   it->selective_display_ellipsis_p
  3276     = !NILP (BVAR (current_buffer, selective_display_ellipses));
  3277 
  3278   /* Display table to use.  */
  3279   it->dp = window_display_table (w);
  3280 
  3281   /* Are multibyte characters enabled in current_buffer?  */
  3282   it->multibyte_p = !NILP (BVAR (current_buffer, enable_multibyte_characters));
  3283 
  3284   it->tab_width = SANE_TAB_WIDTH (current_buffer);
  3285 
  3286   /* Are lines in the display truncated?  */
  3287   if (TRUNCATE != 0)
  3288     it->line_wrap = TRUNCATE;
  3289   if (base_face_id == DEFAULT_FACE_ID
  3290       && !it->w->hscroll
  3291       && (WINDOW_FULL_WIDTH_P (it->w)
  3292           || NILP (Vtruncate_partial_width_windows)
  3293           || (FIXNUMP (Vtruncate_partial_width_windows)
  3294               /* PXW: Shall we do something about this?  */
  3295               && (XFIXNUM (Vtruncate_partial_width_windows)
  3296                   <= WINDOW_TOTAL_COLS (it->w))))
  3297       && NILP (BVAR (current_buffer, truncate_lines)))
  3298     it->line_wrap = NILP (BVAR (current_buffer, word_wrap))
  3299       ? WINDOW_WRAP : WORD_WRAP;
  3300 
  3301   /* Get dimensions of truncation and continuation glyphs.  These are
  3302      displayed as fringe bitmaps under X, but we need them for such
  3303      frames when the fringes are turned off.  The no_special_glyphs slot
  3304      of the iterator's frame, when set, suppresses their display - by
  3305      default for tooltip frames and when set via the 'no-special-glyphs'
  3306      frame parameter.  */
  3307 #ifdef HAVE_WINDOW_SYSTEM
  3308   if (!(FRAME_WINDOW_P (it->f) && it->f->no_special_glyphs))
  3309 #endif
  3310     {
  3311       if (it->line_wrap == TRUNCATE)
  3312         {
  3313           /* We will need the truncation glyph.  */
  3314           eassert (it->glyph_row == NULL);
  3315           produce_special_glyphs (it, IT_TRUNCATION);
  3316           it->truncation_pixel_width = it->pixel_width;
  3317         }
  3318       else
  3319         {
  3320           /* We will need the continuation glyph.  */
  3321           eassert (it->glyph_row == NULL);
  3322           produce_special_glyphs (it, IT_CONTINUATION);
  3323           it->continuation_pixel_width = it->pixel_width;
  3324         }
  3325     }
  3326 
  3327   /* Reset these values to zero because the produce_special_glyphs
  3328      above has changed them.  */
  3329   it->pixel_width = it->ascent = it->descent = 0;
  3330   it->phys_ascent = it->phys_descent = 0;
  3331 
  3332   /* Set this after getting the dimensions of truncation and
  3333      continuation glyphs, so that we don't produce glyphs when calling
  3334      produce_special_glyphs, above.  */
  3335   it->glyph_row = row;
  3336   it->area = TEXT_AREA;
  3337 
  3338   /* Get the dimensions of the display area.  The display area
  3339      consists of the visible window area plus a horizontally scrolled
  3340      part to the left of the window.  All x-values are relative to the
  3341      start of this total display area.  */
  3342   if (base_face_id != DEFAULT_FACE_ID)
  3343     {
  3344       /* Mode lines, menu bar in terminal frames.  */
  3345       it->first_visible_x = 0;
  3346       it->last_visible_x =
  3347         WINDOW_PIXEL_WIDTH (w) - WINDOW_RIGHT_DIVIDER_WIDTH (w);
  3348     }
  3349   else
  3350     {
  3351       /* When hscrolling only the current line, don't apply the
  3352          hscroll here, it will be applied by display_line when it gets
  3353          to laying out the line showing point.  However, if the
  3354          window's min_hscroll is positive, the user specified a lower
  3355          bound for automatic hscrolling, so they expect the
  3356          non-current lines to obey that hscroll amount.  */
  3357       if (hscrolling_current_line_p (w))
  3358         {
  3359           if (w->min_hscroll > 0)
  3360             it->first_visible_x = w->min_hscroll * FRAME_COLUMN_WIDTH (it->f);
  3361           else
  3362             it->first_visible_x = 0;
  3363         }
  3364       else
  3365         it->first_visible_x =
  3366           window_hscroll_limited (w, it->f) * FRAME_COLUMN_WIDTH (it->f);
  3367 
  3368       body_width = window_box_width (w, TEXT_AREA);
  3369       if (!w->pseudo_window_p && !MINI_WINDOW_P (w)
  3370           && body_width != w->old_body_pixel_width)
  3371         FRAME_WINDOW_CHANGE (it->f) = true;
  3372       it->last_visible_x = it->first_visible_x + body_width;
  3373 
  3374       /* If we truncate lines, leave room for the truncation glyph(s) at
  3375          the right margin.  Otherwise, leave room for the continuation
  3376          glyph(s).  Done only if the window has no right fringe.  */
  3377       if (WINDOW_RIGHT_FRINGE_WIDTH (it->w) == 0)
  3378         {
  3379           if (it->line_wrap == TRUNCATE)
  3380             it->last_visible_x -= it->truncation_pixel_width;
  3381           else
  3382             it->last_visible_x -= it->continuation_pixel_width;
  3383         }
  3384 
  3385       it->tab_line_p = window_wants_tab_line (w);
  3386       it->header_line_p = window_wants_header_line (w);
  3387       body_height = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
  3388       it->current_y =  body_height + w->vscroll;
  3389     }
  3390 
  3391   /* Leave room for a border glyph.  */
  3392   if (!FRAME_WINDOW_P (it->f)
  3393       && !WINDOW_RIGHTMOST_P (it->w))
  3394     it->last_visible_x -= 1;
  3395 
  3396   it->last_visible_y = window_text_bottom_y (w);
  3397   body_height += it->last_visible_y;
  3398   if (!w->pseudo_window_p && !MINI_WINDOW_P (w)
  3399       && body_height != w->old_body_pixel_height)
  3400     FRAME_WINDOW_CHANGE (it->f) = true;
  3401 
  3402   /* For mode lines and alike, arrange for the first glyph having a
  3403      left box line if the face specifies a box.  */
  3404   if (base_face_id != DEFAULT_FACE_ID)
  3405     {
  3406       struct face *face;
  3407 
  3408       it->face_id = remapped_base_face_id;
  3409 
  3410       /* If we have a boxed mode line, make the first character appear
  3411          with a left box line.  */
  3412       face = FACE_FROM_ID_OR_NULL (it->f, remapped_base_face_id);
  3413       if (face && face->box != FACE_NO_BOX)
  3414         {
  3415           int box_thickness = face->box_vertical_line_width;
  3416           it->face_box_p = true;
  3417           it->start_of_box_run_p = true;
  3418           /* Make sure we will have enough horizontal space to add the
  3419              right box line at the end.  */
  3420           if (box_thickness > 0)
  3421             it->last_visible_x -= box_thickness;
  3422         }
  3423     }
  3424 
  3425   /* If a buffer position was specified, set the iterator there,
  3426      getting overlays and face properties from that position.  */
  3427   if (charpos >= BUF_BEG (current_buffer))
  3428     {
  3429       it->stop_charpos = charpos;
  3430       it->end_charpos = ZV;
  3431       eassert (charpos == BYTE_TO_CHAR (bytepos));
  3432       IT_CHARPOS (*it) = charpos;
  3433       IT_BYTEPOS (*it) = bytepos;
  3434 
  3435       /* We will rely on `reseat' to set this up properly, via
  3436          handle_face_prop.  */
  3437       it->face_id = it->base_face_id;
  3438 
  3439       it->start = it->current;
  3440       /* Do we need to reorder bidirectional text?  Not if this is a
  3441          unibyte buffer: by definition, none of the single-byte
  3442          characters are strong R2L, so no reordering is needed.  And
  3443          bidi.c doesn't support unibyte buffers anyway.  Also, don't
  3444          reorder while we are loading loadup.el, since the tables of
  3445          character properties needed for reordering are not yet
  3446          available.  */
  3447       it->bidi_p =
  3448         !redisplay__inhibit_bidi
  3449         && !NILP (BVAR (current_buffer, bidi_display_reordering))
  3450         && it->multibyte_p;
  3451 
  3452       /* If we are to reorder bidirectional text, init the bidi
  3453          iterator.  */
  3454       if (it->bidi_p)
  3455         {
  3456           /*  Since we don't know at this point whether there will be
  3457               any R2L lines in the window, we reserve space for
  3458               truncation/continuation glyphs even if only the left
  3459               fringe is absent.  */
  3460           if (base_face_id == DEFAULT_FACE_ID
  3461               && WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0
  3462               && WINDOW_RIGHT_FRINGE_WIDTH (it->w) != 0)
  3463             {
  3464               if (it->line_wrap == TRUNCATE)
  3465                 it->last_visible_x -= it->truncation_pixel_width;
  3466               else
  3467                 it->last_visible_x -= it->continuation_pixel_width;
  3468             }
  3469           /* Note the paragraph direction that this buffer wants to
  3470              use.  */
  3471           if (EQ (BVAR (current_buffer, bidi_paragraph_direction),
  3472                   Qleft_to_right))
  3473             it->paragraph_embedding = L2R;
  3474           else if (EQ (BVAR (current_buffer, bidi_paragraph_direction),
  3475                        Qright_to_left))
  3476             it->paragraph_embedding = R2L;
  3477           else
  3478             it->paragraph_embedding = NEUTRAL_DIR;
  3479           bidi_unshelve_cache (NULL, false);
  3480           bidi_init_it (charpos, IT_BYTEPOS (*it), FRAME_WINDOW_P (it->f),
  3481                         &it->bidi_it);
  3482         }
  3483 
  3484       /* This is set only when long_line_optimizations_p is non-zero
  3485          for the current buffer.  */
  3486       it->medium_narrowing_begv = 0;
  3487 
  3488       /* Compute faces etc.  */
  3489       reseat (it, it->current.pos, true);
  3490     }
  3491 
  3492   CHECK_IT (it);
  3493 }
  3494 
  3495 /* How Emacs deals with long lines.
  3496 
  3497    (1) When a buffer is about to be (re)displayed, 'redisplay_window'
  3498    detects, with a heuristic, whether it contains long lines.
  3499 
  3500    This happens in 'redisplay_window' because it is only displaying
  3501    buffers with long lines that is problematic.  In other words, none
  3502    of the optimizations described below is ever used in buffers that
  3503    are never displayed.
  3504 
  3505    This happens with a heuristic, which checks whether a buffer
  3506    contains long lines, each time its contents have changed "enough"
  3507    between two redisplay cycles, because a buffer without long lines
  3508    can become a buffer with long lines at any time, for example after
  3509    a yank command, or after a replace command, or while the output of
  3510    an external process is inserted in a buffer.
  3511 
  3512    When Emacs has detected that a buffer contains long lines, the
  3513    buffer-local variable 'long_line_optimizations_p' (in 'struct
  3514    buffer') is set, and Emacs does not try to detect whether the
  3515    buffer does or does not contain long lines anymore.
  3516 
  3517    What a long line is depends on the variable 'long-line-threshold',
  3518    whose default value is 50000 (characters).
  3519 
  3520    (2) When a buffer with long lines is (re)displayed, the amount of
  3521    data that the display routines consider is, in a few well-chosen
  3522    places, limited with a temporary restriction, whose bounds are
  3523    calculated with the functions below.
  3524 
  3525    (2.1) 'get_small_narrowing_begv' is used to create a restriction
  3526    which starts a few hundred characters before point.  The exact
  3527    number of characters depends on the width of the window in which
  3528    the buffer is displayed.
  3529 
  3530    There is no corresponding 'get_small_narrowing_zv' function,
  3531    because it is not necessary to set the end limit of that
  3532    restriction.
  3533 
  3534    This restriction is used in four places, namely:
  3535    'back_to_previous_line_start' and 'move_it_vertically_backward'
  3536    (with the 'SET_WITH_NARROWED_BEGV' macro), and in
  3537    'composition_compute_stop_pos' and 'find_automatic_composition' (in
  3538    a conditional statement depending on 'long_line_optimizations_p').
  3539 
  3540    (2.2) 'get_medium_narrowing_begv' is used to create a restriction
  3541    which starts a few thousand characters before point.  The exact
  3542    number of characters depends on the size (width and height) of the
  3543    window in which the buffer is displayed.  For performance reasons,
  3544    the return value of that function is cached in 'struct it', in the
  3545    'medium_narrowing_begv' field.
  3546 
  3547    The corresponding function 'get_medium_narrowing_zv' (and
  3548    'medium_narrowing_zv' field in 'struct it') is not used to set the
  3549    end limit of the restriction, which is again unnecessary, but to
  3550    determine, in 'reseat', whether the iterator has moved far enough
  3551    from its original position, and whether the start position of the
  3552    restriction must be computed anew.
  3553 
  3554    This restriction is used in a single place:
  3555    'get_visually_first_element', with the 'SET_WITH_NARROWED_BEGV'
  3556    macro.
  3557 
  3558    (2.3) 'get_large_narrowing_begv' and 'get_large_narrowing_zv' are
  3559    used to create a restriction which starts a few hundred thousand
  3560    characters before point and ends a few hundred thousand characters
  3561    after point.  The size of that restriction depends on the variable
  3562    'long-line-optimizations-region-size', whose default value is
  3563    500000 (characters); it can be adjusted by a few hundred characters
  3564    depending on 'long-line-optimizations-bol-search-limit', whose
  3565    default value is 128 (characters).
  3566 
  3567    For performance reasons again, the return values of these functions
  3568    are stored in the 'large_narrowing_begv' and 'large_narrowing_zv'
  3569    fields in 'struct it'.
  3570 
  3571    The restriction defined by these values is used around three
  3572    low-level hooks: around 'fontification-functions', in
  3573    'handle_fontified_prop', and around 'pre-command-hook' and
  3574    'post-command-hook', in 'safe_run_hooks_maybe_narrowed', which is
  3575    called in 'command_loop_1'.  These restrictions are set around
  3576    these hooks with 'labeled_narrow_to_region'; the restrictions are
  3577    labeled, and cannot be removed with a call to 'widen', but can be
  3578    removed with 'without-restriction' with a :label argument.
  3579 */
  3580 
  3581 static int
  3582 get_narrowed_width (struct window *w)
  3583 {
  3584   /* In a character-only terminal, only one font size is used, so we
  3585      can use a smaller factor.  */
  3586   int fact = FRAME_WINDOW_P (XFRAME (w->frame)) ? 3 : 2;
  3587   /* If the window has no fringes (in a character-only terminal or in
  3588      a GUI frame without fringes), subtract 1 from the width for the
  3589      '\' line wrapping character.  */
  3590   int width = window_body_width (w, WINDOW_BODY_IN_CANONICAL_CHARS)
  3591     - ((WINDOW_RIGHT_FRINGE_WIDTH (w) == 0
  3592         || WINDOW_LEFT_FRINGE_WIDTH (w) == 0) ? 1 : 0);
  3593   return fact * max (1, width);
  3594 }
  3595 
  3596 static int
  3597 get_narrowed_len (struct window *w)
  3598 {
  3599   int height = window_body_height (w, WINDOW_BODY_IN_CANONICAL_CHARS);
  3600   return get_narrowed_width (w) * max (1, height);
  3601 }
  3602 
  3603 static ptrdiff_t
  3604 get_medium_narrowing_begv (struct window *w, ptrdiff_t pos)
  3605 {
  3606   int len = get_narrowed_len (w);
  3607   return max ((pos / len - 1) * len, BEGV);
  3608 }
  3609 
  3610 static ptrdiff_t
  3611 get_medium_narrowing_zv (struct window *w, ptrdiff_t pos)
  3612 {
  3613   int len = get_narrowed_len (w);
  3614   return min ((pos / len + 1) * len, ZV);
  3615 }
  3616 
  3617 /* Find the position of the last BOL before POS, unless it is too far
  3618    away.  The buffer portion in which the search occurs is gradually
  3619    enlarged: [POS-500..POS], [POS-5500..POS-500],
  3620    [POS-55500..POS-5500], and finally [POS-555500..POS-55500].  Return
  3621    BEGV-1 if no BOL was found in [POS-555500..POS].  */
  3622 static ptrdiff_t
  3623 get_nearby_bol_pos (ptrdiff_t pos)
  3624 {
  3625   ptrdiff_t start, pos_bytepos, cur, next, found, bol = BEGV - 1, init_pos = pos;
  3626   int dist;
  3627   for (dist = 500; dist <= 500000; dist *= 10)
  3628     {
  3629       pos_bytepos = pos == BEGV ? BEGV_BYTE : CHAR_TO_BYTE (pos);
  3630       start = pos - dist < BEGV ? BEGV : pos - dist;
  3631       for (cur = start; cur < pos; cur = next)
  3632         {
  3633           next = find_newline1 (cur, CHAR_TO_BYTE (cur),
  3634                                 pos, pos_bytepos,
  3635                                 1, &found, NULL, false);
  3636           if (found)
  3637             bol = next;
  3638           else
  3639             break;
  3640         }
  3641       if (bol >= BEGV || start == BEGV)
  3642         break;
  3643       else
  3644         pos = pos - dist < BEGV ? BEGV : pos - dist;
  3645     }
  3646   eassert (bol <= init_pos);
  3647   return bol;
  3648 }
  3649 
  3650 ptrdiff_t
  3651 get_small_narrowing_begv (struct window *w, ptrdiff_t pos)
  3652 {
  3653   int len = get_narrowed_width (w);
  3654   ptrdiff_t bol_pos = max (get_nearby_bol_pos (pos), BEGV);
  3655   return max (bol_pos + ((pos - bol_pos) / len - 1) * len, BEGV);
  3656 }
  3657 
  3658 ptrdiff_t
  3659 get_large_narrowing_begv (ptrdiff_t pos)
  3660 {
  3661   if (long_line_optimizations_region_size <= 0)
  3662     return BEGV;
  3663   int len = long_line_optimizations_region_size / 2;
  3664   int begv = max (pos - len, BEGV);
  3665   int limit = long_line_optimizations_bol_search_limit;
  3666   while (limit > 0)
  3667     {
  3668       if (begv == BEGV || FETCH_BYTE (CHAR_TO_BYTE (begv) - 1) == '\n')
  3669         return begv;
  3670       begv--;
  3671       limit--;
  3672     }
  3673   return begv;
  3674 }
  3675 
  3676 ptrdiff_t
  3677 get_large_narrowing_zv (ptrdiff_t pos)
  3678 {
  3679   if (long_line_optimizations_region_size <= 0)
  3680     return ZV;
  3681   int len = long_line_optimizations_region_size / 2;
  3682   return min (pos + len, ZV);
  3683 }
  3684 
  3685 static void
  3686 unwind_narrowed_begv (Lisp_Object point_min)
  3687 {
  3688   SET_BUF_BEGV (current_buffer, XFIXNUM (point_min));
  3689 }
  3690 
  3691 /* Set DST to EXPR.  When IT indicates that BEGV should temporarily be
  3692    updated to optimize display, evaluate EXPR with BEGV set to BV.  */
  3693 
  3694 #define SET_WITH_NARROWED_BEGV(IT,DST,EXPR,BV)                          \
  3695   do {                                                                  \
  3696     if (IT->medium_narrowing_begv)                                      \
  3697       {                                                                 \
  3698         specpdl_ref count = SPECPDL_INDEX ();                           \
  3699         record_unwind_protect (unwind_narrowed_begv, Fpoint_min ());    \
  3700         SET_BUF_BEGV (current_buffer, BV);                              \
  3701         DST = EXPR;                                                     \
  3702         unbind_to (count, Qnil);                                        \
  3703       }                                                                 \
  3704     else                                                                \
  3705       DST = EXPR;                                                       \
  3706   } while (0)
  3707 
  3708 /* Initialize IT for the display of window W with window start POS.  */
  3709 
  3710 void
  3711 start_display (struct it *it, struct window *w, struct text_pos pos)
  3712 {
  3713   struct glyph_row *row;
  3714   int first_vpos = window_wants_tab_line (w) + window_wants_header_line (w);
  3715 
  3716   row = w->desired_matrix->rows + first_vpos;
  3717   init_iterator (it, w, CHARPOS (pos), BYTEPOS (pos), row, DEFAULT_FACE_ID);
  3718   it->first_vpos = first_vpos;
  3719 
  3720   /* Don't reseat to previous visible line start if current start
  3721      position is in a string or image.  */
  3722   if (it->method == GET_FROM_BUFFER && it->line_wrap != TRUNCATE)
  3723     {
  3724       int first_y = it->current_y;
  3725 
  3726       /* If window start is not at a line start, skip forward to POS to
  3727          get the correct continuation lines width.  */
  3728       bool start_at_line_beg_p = (CHARPOS (pos) == BEGV
  3729                                   || FETCH_BYTE (BYTEPOS (pos) - 1) == '\n');
  3730       if (!start_at_line_beg_p)
  3731         {
  3732           int new_x;
  3733 
  3734           reseat_at_previous_visible_line_start (it);
  3735           move_it_to (it, CHARPOS (pos), -1, -1, -1, MOVE_TO_POS);
  3736 
  3737           new_x = it->current_x + it->pixel_width;
  3738 
  3739           /* If lines are continued, this line may end in the middle
  3740              of a multi-glyph character (e.g. a control character
  3741              displayed as \003, or in the middle of an overlay
  3742              string).  In this case move_it_to above will not have
  3743              taken us to the start of the continuation line but to the
  3744              end of the continued line.  */
  3745           if (it->current_x > 0
  3746               && it->line_wrap != TRUNCATE /* Lines are continued.  */
  3747               && (/* And glyph doesn't fit on the line.  */
  3748                   new_x > it->last_visible_x
  3749                   /* Or it fits exactly and we're on a window
  3750                      system frame.  */
  3751                   || (new_x == it->last_visible_x
  3752                       && FRAME_WINDOW_P (it->f)
  3753                       && ((it->bidi_p && it->bidi_it.paragraph_dir == R2L)
  3754                           ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
  3755                           : WINDOW_RIGHT_FRINGE_WIDTH (it->w)))))
  3756             {
  3757               if ((it->current.dpvec_index >= 0
  3758                    || it->current.overlay_string_index >= 0)
  3759                   /* If we are on a newline from a display vector or
  3760                      overlay string, then we are already at the end of
  3761                      a screen line; no need to go to the next line in
  3762                      that case, as this line is not really continued.
  3763                      (If we do go to the next line, C-e will not DTRT.)  */
  3764                   && it->c != '\n')
  3765                 {
  3766                   set_iterator_to_next (it, true);
  3767                   move_it_in_display_line_to (it, -1, -1, 0);
  3768                 }
  3769 
  3770               it->continuation_lines_width += it->current_x;
  3771             }
  3772           /* If the character at POS is displayed via a display
  3773              vector, move_it_to above stops at the final glyph of
  3774              IT->dpvec.  To make the caller redisplay that character
  3775              again (a.k.a. start at POS), we need to reset the
  3776              dpvec_index to the beginning of IT->dpvec.  */
  3777           else if (it->current.dpvec_index >= 0)
  3778             it->current.dpvec_index = 0;
  3779 
  3780           /* We're starting a new display line, not affected by the
  3781              height of the continued line, so clear the appropriate
  3782              fields in the iterator structure.  */
  3783           it->max_ascent = it->max_descent = 0;
  3784           it->max_phys_ascent = it->max_phys_descent = 0;
  3785 
  3786           it->current_y = first_y;
  3787           it->vpos = 0;
  3788           it->current_x = it->hpos = 0;
  3789         }
  3790     }
  3791 }
  3792 
  3793 
  3794 /* Return true if POS is a position in ellipses displayed for invisible
  3795    text.  W is the window we display, for text property lookup.  */
  3796 
  3797 static bool
  3798 in_ellipses_for_invisible_text_p (struct display_pos *pos, struct window *w)
  3799 {
  3800   Lisp_Object prop, window;
  3801   bool ellipses_p = false;
  3802   ptrdiff_t charpos = CHARPOS (pos->pos);
  3803 
  3804   /* If POS specifies a position in a display vector, this might
  3805      be for an ellipsis displayed for invisible text.  We won't
  3806      get the iterator set up for delivering that ellipsis unless
  3807      we make sure that it gets aware of the invisible text.  */
  3808   if (pos->dpvec_index >= 0
  3809       && pos->overlay_string_index < 0
  3810       && CHARPOS (pos->string_pos) < 0
  3811       && charpos > BEGV
  3812       && (XSETWINDOW (window, w),
  3813           prop = Fget_char_property (make_fixnum (charpos),
  3814                                      Qinvisible, window),
  3815           TEXT_PROP_MEANS_INVISIBLE (prop) == 0))
  3816     {
  3817       prop = Fget_char_property (make_fixnum (charpos - 1), Qinvisible,
  3818                                  window);
  3819       ellipses_p = 2 == TEXT_PROP_MEANS_INVISIBLE (prop);
  3820     }
  3821 
  3822   return ellipses_p;
  3823 }
  3824 
  3825 
  3826 /* Initialize IT for stepping through current_buffer in window W,
  3827    starting at position POS that includes overlay string and display
  3828    vector/ control character translation position information.  Value
  3829    is false if there are overlay strings with newlines at POS.  */
  3830 
  3831 static bool
  3832 init_from_display_pos (struct it *it, struct window *w, struct display_pos *pos)
  3833 {
  3834   ptrdiff_t charpos = CHARPOS (pos->pos), bytepos = BYTEPOS (pos->pos);
  3835   int i;
  3836   bool overlay_strings_with_newlines = false;
  3837 
  3838   /* If POS specifies a position in a display vector, this might
  3839      be for an ellipsis displayed for invisible text.  We won't
  3840      get the iterator set up for delivering that ellipsis unless
  3841      we make sure that it gets aware of the invisible text.  */
  3842   if (in_ellipses_for_invisible_text_p (pos, w))
  3843     {
  3844       --charpos;
  3845       bytepos = 0;
  3846     }
  3847 
  3848   /* Keep in mind: the call to reseat in init_iterator skips invisible
  3849      text, so we might end up at a position different from POS.  This
  3850      is only a problem when POS is a row start after a newline and an
  3851      overlay starts there with an after-string, and the overlay has an
  3852      invisible property.  Since we don't skip invisible text in
  3853      display_line and elsewhere immediately after consuming the
  3854      newline before the row start, such a POS will not be in a string,
  3855      but the call to init_iterator below will move us to the
  3856      after-string.  */
  3857   init_iterator (it, w, charpos, bytepos, NULL, DEFAULT_FACE_ID);
  3858 
  3859   /* This only scans the current chunk -- it should scan all chunks.
  3860      However, OVERLAY_STRING_CHUNK_SIZE has been increased from 3 in 21.1
  3861      to 16 in 22.1 to make this a lesser problem.  */
  3862   for (i = 0; i < it->n_overlay_strings && i < OVERLAY_STRING_CHUNK_SIZE; ++i)
  3863     {
  3864       const char *s = SSDATA (it->overlay_strings[i]);
  3865       const char *e = s + SBYTES (it->overlay_strings[i]);
  3866 
  3867       while (s < e && *s != '\n')
  3868         ++s;
  3869 
  3870       if (s < e)
  3871         {
  3872           overlay_strings_with_newlines = true;
  3873           break;
  3874         }
  3875     }
  3876 
  3877   /* If position is within an overlay string, set up IT to the right
  3878      overlay string.  */
  3879   if (pos->overlay_string_index >= 0)
  3880     {
  3881       int relative_index;
  3882 
  3883       /* If the first overlay string happens to have a `display'
  3884          property for an image, the iterator will be set up for that
  3885          image, and we have to undo that setup first before we can
  3886          correct the overlay string index.  */
  3887       if (it->method == GET_FROM_IMAGE)
  3888         pop_it (it);
  3889 
  3890       /* We already have the first chunk of overlay strings in
  3891          IT->overlay_strings.  Load more until the one for
  3892          pos->overlay_string_index is in IT->overlay_strings.  */
  3893       if (pos->overlay_string_index >= OVERLAY_STRING_CHUNK_SIZE)
  3894         {
  3895           ptrdiff_t n = pos->overlay_string_index / OVERLAY_STRING_CHUNK_SIZE;
  3896           it->current.overlay_string_index = 0;
  3897           while (n--)
  3898             {
  3899               load_overlay_strings (it, 0);
  3900               it->current.overlay_string_index += OVERLAY_STRING_CHUNK_SIZE;
  3901             }
  3902         }
  3903 
  3904       it->current.overlay_string_index = pos->overlay_string_index;
  3905       relative_index = (it->current.overlay_string_index
  3906                         % OVERLAY_STRING_CHUNK_SIZE);
  3907       it->string = it->overlay_strings[relative_index];
  3908       eassert (STRINGP (it->string));
  3909       it->current.string_pos = pos->string_pos;
  3910       it->method = GET_FROM_STRING;
  3911       it->end_charpos = SCHARS (it->string);
  3912       /* Set up the bidi iterator for this overlay string.  */
  3913       if (it->bidi_p)
  3914         {
  3915           it->bidi_it.string.lstring = it->string;
  3916           it->bidi_it.string.s = NULL;
  3917           it->bidi_it.string.schars = SCHARS (it->string);
  3918           it->bidi_it.string.bufpos = it->overlay_strings_charpos;
  3919           it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
  3920           it->bidi_it.string.unibyte = !it->multibyte_p;
  3921           it->bidi_it.w = it->w;
  3922           bidi_init_it (IT_STRING_CHARPOS (*it), IT_STRING_BYTEPOS (*it),
  3923                         FRAME_WINDOW_P (it->f), &it->bidi_it);
  3924 
  3925           /* Synchronize the state of the bidi iterator with
  3926              pos->string_pos.  For any string position other than
  3927              zero, this will be done automagically when we resume
  3928              iteration over the string and get_visually_first_element
  3929              is called.  But if string_pos is zero, and the string is
  3930              to be reordered for display, we need to resync manually,
  3931              since it could be that the iteration state recorded in
  3932              pos ended at string_pos of 0 moving backwards in string.  */
  3933           if (CHARPOS (pos->string_pos) == 0)
  3934             {
  3935               get_visually_first_element (it);
  3936               if (IT_STRING_CHARPOS (*it) != 0)
  3937                 do {
  3938                   /* Paranoia.  */
  3939                   eassert (it->bidi_it.charpos < it->bidi_it.string.schars);
  3940                   bidi_move_to_visually_next (&it->bidi_it);
  3941                 } while (it->bidi_it.charpos != 0);
  3942             }
  3943           eassert (IT_STRING_CHARPOS (*it) == it->bidi_it.charpos
  3944                    && IT_STRING_BYTEPOS (*it) == it->bidi_it.bytepos);
  3945         }
  3946     }
  3947 
  3948   if (CHARPOS (pos->string_pos) >= 0)
  3949     {
  3950       /* Recorded position is not in an overlay string, but in another
  3951          string.  This can only be a string from a `display' property.
  3952          IT should already be filled with that string.  */
  3953       it->current.string_pos = pos->string_pos;
  3954       eassert (STRINGP (it->string));
  3955       if (it->bidi_p)
  3956         bidi_init_it (IT_STRING_CHARPOS (*it), IT_STRING_BYTEPOS (*it),
  3957                       FRAME_WINDOW_P (it->f), &it->bidi_it);
  3958     }
  3959 
  3960   /* Restore position in display vector translations, control
  3961      character translations or ellipses.  */
  3962   if (pos->dpvec_index >= 0)
  3963     {
  3964       if (it->dpvec == NULL)
  3965         get_next_display_element (it);
  3966       eassert (it->dpvec && it->current.dpvec_index == 0);
  3967       it->current.dpvec_index = pos->dpvec_index;
  3968     }
  3969 
  3970   CHECK_IT (it);
  3971   return !overlay_strings_with_newlines;
  3972 }
  3973 
  3974 
  3975 /* Initialize IT for stepping through current_buffer in window W
  3976    starting at ROW->start.  */
  3977 
  3978 static void
  3979 init_to_row_start (struct it *it, struct window *w, struct glyph_row *row)
  3980 {
  3981   init_from_display_pos (it, w, &row->start);
  3982   it->start = row->start;
  3983   it->continuation_lines_width = row->continuation_lines_width;
  3984   CHECK_IT (it);
  3985 }
  3986 
  3987 
  3988 /* Initialize IT for stepping through current_buffer in window W
  3989    starting in the line following ROW, i.e. starting at ROW->end.
  3990    Value is false if there are overlay strings with newlines at ROW's
  3991    end position, or if the following row begins with bidi-reordered
  3992    characters that could be composed.  */
  3993 
  3994 static bool
  3995 init_to_row_end (struct it *it, struct window *w, struct glyph_row *row)
  3996 {
  3997   bool success = false;
  3998 
  3999   if (init_from_display_pos (it, w, &row->end))
  4000     {
  4001       if (row->continued_p)
  4002         it->continuation_lines_width
  4003           = row->continuation_lines_width + row->pixel_width;
  4004       CHECK_IT (it);
  4005       /* Initializing IT in the presence of compositions in reordered
  4006          rows is tricky: row->end above will generally cause us to
  4007          start at position that is not the first one in the logical
  4008          order, and we might therefore miss the composition earlier in
  4009          the buffer that affects how glypsh are laid out in this row.
  4010          So we punt instead.  Note: the test below works because
  4011          get_next_display_element calls get_visually_first_element,
  4012          which calls composition_compute_stop_pos, which populates
  4013          it->cmp_it.  */
  4014       if (get_next_display_element (it)
  4015           && (it->bidi_it.scan_dir == -1 && it->cmp_it.id >= 0))
  4016         success = false;
  4017       else
  4018         success = true;
  4019     }
  4020 
  4021   return success;
  4022 }
  4023 
  4024 
  4025 
  4026 
  4027 /***********************************************************************
  4028                            Text properties
  4029  ***********************************************************************/
  4030 
  4031 /* Called when IT reaches IT->stop_charpos.  Handle text property and
  4032    overlay changes.  Set IT->stop_charpos to the next position where
  4033    to stop.  */
  4034 
  4035 static void
  4036 handle_stop (struct it *it)
  4037 {
  4038   enum prop_handled handled;
  4039   bool handle_overlay_change_p;
  4040   struct props *p;
  4041 
  4042   it->dpvec = NULL;
  4043   it->current.dpvec_index = -1;
  4044   handle_overlay_change_p = !it->ignore_overlay_strings_at_pos_p;
  4045   it->ellipsis_p = false;
  4046 
  4047   /* Use face of preceding text for ellipsis (if invisible) */
  4048   if (it->selective_display_ellipsis_p)
  4049     it->saved_face_id = it->face_id;
  4050 
  4051   /* Here's the description of the semantics of, and the logic behind,
  4052      the various HANDLED_* statuses:
  4053 
  4054      HANDLED_NORMALLY means the handler did its job, and the loop
  4055      should proceed to calling the next handler in order.
  4056 
  4057      HANDLED_RECOMPUTE_PROPS means the handler caused a significant
  4058      change in the properties and overlays at current position, so the
  4059      loop should be restarted, to re-invoke the handlers that were
  4060      already called.  This happens when fontification-functions were
  4061      called by handle_fontified_prop, and actually fontified
  4062      something.  Another case where HANDLED_RECOMPUTE_PROPS is
  4063      returned is when we discover overlay strings that need to be
  4064      displayed right away.  The loop below will continue for as long
  4065      as the status is HANDLED_RECOMPUTE_PROPS.
  4066 
  4067      HANDLED_RETURN means return immediately to the caller, to
  4068      continue iteration without calling any further handlers.  This is
  4069      used when we need to act on some property right away, for example
  4070      when we need to display the ellipsis or a replacing display
  4071      property, such as display string or image.
  4072 
  4073      HANDLED_OVERLAY_STRING_CONSUMED means an overlay string was just
  4074      consumed, and the handler switched to the next overlay string.
  4075      This signals the loop below to refrain from looking for more
  4076      overlays before all the overlay strings of the current overlay
  4077      are processed.
  4078 
  4079      Some of the handlers called by the loop push the iterator state
  4080      onto the stack (see 'push_it'), and arrange for the iteration to
  4081      continue with another object, such as an image, a display string,
  4082      or an overlay string.  In most such cases, it->stop_charpos is
  4083      set to the first character of the string, so that when the
  4084      iteration resumes, this function will immediately be called
  4085      again, to examine the properties at the beginning of the string.
  4086 
  4087      When a display or overlay string is exhausted, the iterator state
  4088      is popped (see 'pop_it'), and iteration continues with the
  4089      previous object.  Again, in many such cases this function is
  4090      called again to find the next position where properties might
  4091      change.  */
  4092 
  4093   do
  4094     {
  4095       handled = HANDLED_NORMALLY;
  4096 
  4097       /* Call text property handlers.  */
  4098       for (p = it_props; p->handler; ++p)
  4099         {
  4100           handled = p->handler (it);
  4101 
  4102           if (handled == HANDLED_RECOMPUTE_PROPS)
  4103             break;
  4104           else if (handled == HANDLED_RETURN)
  4105             {
  4106               /* We still want to show before and after strings from
  4107                  overlays even if the actual buffer text is replaced.  */
  4108               if (!handle_overlay_change_p
  4109                   || it->sp > 1
  4110                   /* Don't call get_overlay_strings_1 if we already
  4111                      have overlay strings loaded, because doing so
  4112                      will load them again and push the iterator state
  4113                      onto the stack one more time, which is not
  4114                      expected by the rest of the code that processes
  4115                      overlay strings.  */
  4116                   || (it->current.overlay_string_index < 0
  4117                       && !get_overlay_strings_1 (it, 0, false)))
  4118                 {
  4119                   if (it->ellipsis_p)
  4120                     setup_for_ellipsis (it, 0);
  4121                   /* When handling a display spec, we might load an
  4122                      empty string.  In that case, discard it here.  We
  4123                      used to discard it in handle_single_display_spec,
  4124                      but that causes get_overlay_strings_1, above, to
  4125                      ignore overlay strings that we must check.  */
  4126                   if (STRINGP (it->string) && !SCHARS (it->string))
  4127                     pop_it (it);
  4128                   return;
  4129                 }
  4130               else if (STRINGP (it->string) && !SCHARS (it->string))
  4131                 pop_it (it);
  4132               else
  4133                 {
  4134                   it->string_from_display_prop_p = false;
  4135                   it->from_disp_prop_p = false;
  4136                   handle_overlay_change_p = false;
  4137                 }
  4138               handled = HANDLED_RECOMPUTE_PROPS;
  4139               break;
  4140             }
  4141           else if (handled == HANDLED_OVERLAY_STRING_CONSUMED)
  4142             handle_overlay_change_p = false;
  4143         }
  4144 
  4145       if (handled != HANDLED_RECOMPUTE_PROPS)
  4146         {
  4147           /* Don't check for overlay strings below when set to deliver
  4148              characters from a display vector.  */
  4149           if (it->method == GET_FROM_DISPLAY_VECTOR)
  4150             handle_overlay_change_p = false;
  4151 
  4152           /* Handle overlay changes.
  4153              This sets HANDLED to HANDLED_RECOMPUTE_PROPS
  4154              if it finds overlays.  */
  4155           if (handle_overlay_change_p)
  4156             handled = handle_overlay_change (it);
  4157         }
  4158 
  4159       if (it->ellipsis_p)
  4160         {
  4161           setup_for_ellipsis (it, 0);
  4162           break;
  4163         }
  4164     }
  4165   while (handled == HANDLED_RECOMPUTE_PROPS);
  4166 
  4167   /* Determine where to stop next.  */
  4168   if (handled == HANDLED_NORMALLY)
  4169     compute_stop_pos (it);
  4170 }
  4171 
  4172 
  4173 /* Compute IT->stop_charpos from text property and overlay change
  4174    information for IT's current position.  */
  4175 
  4176 static void
  4177 compute_stop_pos (struct it *it)
  4178 {
  4179   register INTERVAL iv, next_iv;
  4180   Lisp_Object object, limit, position;
  4181   ptrdiff_t charpos, bytepos, cmp_limit_pos = -1;
  4182 
  4183   if (STRINGP (it->string))
  4184     {
  4185       /* Strings are usually short, so don't limit the search for
  4186          properties.  */
  4187       it->stop_charpos = it->end_charpos;
  4188       object = it->string;
  4189       limit = Qnil;
  4190       charpos = IT_STRING_CHARPOS (*it);
  4191       bytepos = IT_STRING_BYTEPOS (*it);
  4192     }
  4193   else
  4194     {
  4195       ptrdiff_t pos;
  4196 
  4197       /* If end_charpos is out of range for some reason, such as a
  4198          misbehaving display function, rationalize it (Bug#5984).  */
  4199       if (it->end_charpos > ZV)
  4200         it->end_charpos = ZV;
  4201       it->stop_charpos = it->end_charpos;
  4202 
  4203       /* If next overlay change is in front of the current stop pos
  4204          (which is IT->end_charpos), stop there.  Note: value of
  4205          next_overlay_change is point-max if no overlay change
  4206          follows.  */
  4207       charpos = IT_CHARPOS (*it);
  4208       bytepos = IT_BYTEPOS (*it);
  4209       pos = next_overlay_change (charpos);
  4210       if (pos < it->stop_charpos)
  4211         it->stop_charpos = pos;
  4212       /* If we are breaking compositions at point, stop at point.  */
  4213       if (!NILP (BVAR (current_buffer, enable_multibyte_characters))
  4214           && !NILP (Vauto_composition_mode)
  4215           && composition_break_at_point
  4216           && charpos < PT && PT < it->stop_charpos)
  4217         it->stop_charpos = PT;
  4218 
  4219       /* Set up variables for computing the stop position from text
  4220          property changes.  */
  4221       XSETBUFFER (object, current_buffer);
  4222       pos = charpos + TEXT_PROP_DISTANCE_LIMIT;
  4223       /* Make sure the above arbitrary limit position is not in the
  4224          middle of composable text, so we don't break compositions by
  4225          submitting the composable text to the shaper in separate
  4226          chunks.  We play safe here by assuming that only SPC, TAB,
  4227          FF, and NL cannot be in some composition; in particular, most
  4228          ASCII punctuation characters could be composed into ligatures.  */
  4229       if (!composition_break_at_point
  4230           && !NILP (BVAR (current_buffer, enable_multibyte_characters))
  4231           && !NILP (Vauto_composition_mode))
  4232         {
  4233           ptrdiff_t endpos = charpos + 10 * TEXT_PROP_DISTANCE_LIMIT;
  4234           bool found = false;
  4235 
  4236           if (pos > ZV)
  4237             pos = ZV;
  4238           if (endpos > ZV)
  4239             endpos = ZV;
  4240           ptrdiff_t bpos = CHAR_TO_BYTE (pos);
  4241           while (pos < endpos)
  4242             {
  4243               int ch = fetch_char_advance_no_check (&pos, &bpos);
  4244               if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\f')
  4245                 {
  4246                   found = true;
  4247                   break;
  4248                 }
  4249             }
  4250           if (found)
  4251             {
  4252               pos--;
  4253               cmp_limit_pos = pos;
  4254             }
  4255           else if (it->stop_charpos < endpos)
  4256             pos = it->stop_charpos;
  4257           else
  4258             {
  4259               /* Give up and use the original arbitrary limit.  */
  4260               pos = charpos + TEXT_PROP_DISTANCE_LIMIT;
  4261             }
  4262         }
  4263       limit = make_fixnum (pos);
  4264     }
  4265 
  4266   /* Get the interval containing IT's position.  Value is a null
  4267      interval if there isn't such an interval.  */
  4268   position = make_fixnum (charpos);
  4269   iv = validate_interval_range (object, &position, &position, false);
  4270   if (iv)
  4271     {
  4272       Lisp_Object values_here[LAST_PROP_IDX];
  4273       struct props *p;
  4274 
  4275       /* Get properties here.  */
  4276       for (p = it_props; p->handler; ++p)
  4277         values_here[p->idx] = textget (iv->plist,
  4278                                        builtin_lisp_symbol (p->name));
  4279 
  4280       /* Look for an interval following iv that has different
  4281          properties.  */
  4282       for (next_iv = next_interval (iv);
  4283            (next_iv
  4284             && (NILP (limit)
  4285                 || XFIXNAT (limit) > next_iv->position));
  4286            next_iv = next_interval (next_iv))
  4287         {
  4288           for (p = it_props; p->handler; ++p)
  4289             {
  4290               Lisp_Object new_value = textget (next_iv->plist,
  4291                                                builtin_lisp_symbol (p->name));
  4292               if (!EQ (values_here[p->idx], new_value))
  4293                 break;
  4294             }
  4295 
  4296           if (p->handler)
  4297             break;
  4298         }
  4299 
  4300       if (next_iv)
  4301         {
  4302           if (FIXNUMP (limit)
  4303               && next_iv->position >= XFIXNAT (limit))
  4304             /* No text property change up to limit.  */
  4305             it->stop_charpos = min (XFIXNAT (limit), it->stop_charpos);
  4306           else
  4307             /* Text properties change in next_iv.  */
  4308             it->stop_charpos = min (it->stop_charpos, next_iv->position);
  4309         }
  4310     }
  4311 
  4312   if (it->cmp_it.id < 0
  4313       && (STRINGP (it->string)
  4314           || ((!it->bidi_p || it->bidi_it.scan_dir >= 0)
  4315               && it->cmp_it.stop_pos <= IT_CHARPOS (*it))))
  4316     {
  4317       ptrdiff_t stoppos = it->end_charpos;
  4318 
  4319       /* If we found, above, a buffer position that cannot be part of
  4320          an automatic composition, limit the search of composable
  4321          characters to that position.  */
  4322       if (it->bidi_p && it->bidi_it.scan_dir < 0)
  4323         stoppos = -1;
  4324       else if (cmp_limit_pos > 0)
  4325         stoppos = cmp_limit_pos;
  4326       /* Force composition_compute_stop_pos avoid the costly search
  4327          for static compositions, since those were already found by
  4328          looking at text properties, above.  */
  4329       composition_compute_stop_pos (&it->cmp_it, charpos, bytepos,
  4330                                     stoppos, it->string, false);
  4331     }
  4332 
  4333   eassert (STRINGP (it->string)
  4334            || (it->stop_charpos >= BEGV
  4335                && it->stop_charpos >= IT_CHARPOS (*it)));
  4336 }
  4337 
  4338 /* How many characters forward to search for a display property or
  4339    display string.  Searching too far forward makes the bidi display
  4340    sluggish, especially in small windows.  */
  4341 #define MAX_DISP_SCAN 250
  4342 
  4343 /* Return the character position of a display string at or after
  4344    position specified by POSITION.  If no display string exists at or
  4345    after POSITION, return ZV.  A display string is either an overlay
  4346    with `display' property whose value is a string, or a `display'
  4347    text property whose value is a string.  STRING is data about the
  4348    string to iterate; if STRING->lstring is nil, we are iterating a
  4349    buffer.  FRAME_WINDOW_P is true when we are displaying a window
  4350    on a GUI frame.  DISP_PROP is set to zero if we searched
  4351    MAX_DISP_SCAN characters forward without finding any display
  4352    strings, non-zero otherwise.  It is set to 2 if the display string
  4353    uses any kind of `(space ...)' spec that will produce a stretch of
  4354    white space in the text area.  */
  4355 ptrdiff_t
  4356 compute_display_string_pos (struct text_pos *position,
  4357                             struct bidi_string_data *string,
  4358                             struct window *w,
  4359                             bool frame_window_p, int *disp_prop)
  4360 {
  4361   /* OBJECT = nil means current buffer.  */
  4362   Lisp_Object object, object1;
  4363   Lisp_Object pos, spec, limpos;
  4364   bool string_p = string && (STRINGP (string->lstring) || string->s);
  4365   ptrdiff_t eob = string_p ? string->schars : ZV;
  4366   ptrdiff_t begb = string_p ? 0 : BEGV;
  4367   ptrdiff_t bufpos, charpos = CHARPOS (*position);
  4368   ptrdiff_t lim =
  4369     (charpos < eob - MAX_DISP_SCAN) ? charpos + MAX_DISP_SCAN : eob;
  4370   struct text_pos tpos;
  4371   int rv = 0;
  4372 
  4373   if (string && STRINGP (string->lstring))
  4374     object1 = object = string->lstring;
  4375   else if (w && !string_p)
  4376     {
  4377       XSETWINDOW (object, w);
  4378       object1 = Qnil;
  4379     }
  4380   else
  4381     object1 = object = Qnil;
  4382 
  4383   *disp_prop = 1;
  4384 
  4385   if (charpos >= eob
  4386       /* We don't support display properties whose values are strings
  4387          that have display string properties.  */
  4388       || string->from_disp_str
  4389       /* C strings cannot have display properties.  */
  4390       || (string->s && !STRINGP (object)))
  4391     {
  4392       *disp_prop = 0;
  4393       return eob;
  4394     }
  4395 
  4396   /* If the character at CHARPOS is where the display string begins,
  4397      return CHARPOS.  */
  4398   pos = make_fixnum (charpos);
  4399   if (STRINGP (object))
  4400     bufpos = string->bufpos;
  4401   else
  4402     bufpos = charpos;
  4403   tpos = *position;
  4404   if (!NILP (spec = Fget_char_property (pos, Qdisplay, object))
  4405       && (charpos <= begb
  4406           || !EQ (Fget_char_property (make_fixnum (charpos - 1), Qdisplay,
  4407                                       object),
  4408                   spec))
  4409       && (rv = handle_display_spec (NULL, spec, object1, Qnil, &tpos, bufpos,
  4410                                     frame_window_p)))
  4411     {
  4412       if (rv == 2)
  4413         *disp_prop = 2;
  4414       return charpos;
  4415     }
  4416 
  4417   /* Look forward for the first character with a `display' property
  4418      that will replace the underlying text when displayed.  */
  4419   limpos = make_fixnum (lim);
  4420   do {
  4421     pos = Fnext_single_char_property_change (pos, Qdisplay, object1, limpos);
  4422     CHARPOS (tpos) = XFIXNAT (pos);
  4423     if (CHARPOS (tpos) >= lim)
  4424       {
  4425         *disp_prop = 0;
  4426         break;
  4427       }
  4428     if (STRINGP (object))
  4429       BYTEPOS (tpos) = string_char_to_byte (object, CHARPOS (tpos));
  4430     else
  4431       BYTEPOS (tpos) = CHAR_TO_BYTE (CHARPOS (tpos));
  4432     spec = Fget_char_property (pos, Qdisplay, object);
  4433     if (!STRINGP (object))
  4434       bufpos = CHARPOS (tpos);
  4435   } while (NILP (spec)
  4436            || !(rv = handle_display_spec (NULL, spec, object1, Qnil, &tpos,
  4437                                           bufpos, frame_window_p)));
  4438   if (rv == 2)
  4439     *disp_prop = 2;
  4440 
  4441   return CHARPOS (tpos);
  4442 }
  4443 
  4444 /* Return the character position of the end of the display string that
  4445    started at CHARPOS.  If there's no display string at CHARPOS,
  4446    return -1.  A display string is either an overlay with `display'
  4447    property whose value is a string or a `display' text property whose
  4448    value is a string.  */
  4449 ptrdiff_t
  4450 compute_display_string_end (ptrdiff_t charpos, struct bidi_string_data *string)
  4451 {
  4452   /* OBJECT = nil means current buffer.  */
  4453   Lisp_Object object =
  4454     (string && STRINGP (string->lstring)) ? string->lstring : Qnil;
  4455   Lisp_Object pos = make_fixnum (charpos);
  4456   ptrdiff_t eob =
  4457     (STRINGP (object) || (string && string->s)) ? string->schars : ZV;
  4458 
  4459   if (charpos >= eob || (string->s && !STRINGP (object)))
  4460     return eob;
  4461 
  4462   /* It could happen that the display property or overlay was removed
  4463      since we found it in compute_display_string_pos above.  One way
  4464      this can happen is if JIT font-lock was called (through
  4465      handle_fontified_prop), and jit-lock-functions remove text
  4466      properties or overlays from the portion of buffer that includes
  4467      CHARPOS.  Muse mode is known to do that, for example.  In this
  4468      case, we return -1 to the caller, to signal that no display
  4469      string is actually present at CHARPOS.  See bidi_fetch_char for
  4470      how this is handled.
  4471 
  4472      An alternative would be to never look for display properties past
  4473      it->stop_charpos.  But neither compute_display_string_pos nor
  4474      bidi_fetch_char that calls it know or care where the next
  4475      stop_charpos is.  */
  4476   if (NILP (Fget_char_property (pos, Qdisplay, object)))
  4477     return -1;
  4478 
  4479   /* Look forward for the first character where the `display' property
  4480      changes.  */
  4481   pos = Fnext_single_char_property_change (pos, Qdisplay, object, Qnil);
  4482 
  4483   return XFIXNAT (pos);
  4484 }
  4485 
  4486 
  4487 
  4488 /***********************************************************************
  4489                             Fontification
  4490  ***********************************************************************/
  4491 
  4492 /* Handle changes in the `fontified' property of the current buffer by
  4493    calling hook functions from Qfontification_functions to fontify
  4494    regions of text.  */
  4495 
  4496 static enum prop_handled
  4497 handle_fontified_prop (struct it *it)
  4498 {
  4499   Lisp_Object prop, pos;
  4500   enum prop_handled handled = HANDLED_NORMALLY;
  4501 
  4502   if (!NILP (Vmemory_full))
  4503     return handled;
  4504 
  4505   /* Get the value of the `fontified' property at IT's current buffer
  4506      position.  (The `fontified' property doesn't have a special
  4507      meaning in strings.)  If the value is nil, call functions from
  4508      Qfontification_functions.  */
  4509   if (!STRINGP (it->string)
  4510       && it->s == NULL
  4511       && !NILP (Vfontification_functions)
  4512       && !(input_was_pending && redisplay_skip_fontification_on_input)
  4513       && !NILP (Vrun_hooks)
  4514       && (pos = make_fixnum (IT_CHARPOS (*it)),
  4515           prop = Fget_char_property (pos, Qfontified, Qnil),
  4516           /* Ignore the special cased nil value always present at EOB since
  4517              no amount of fontifying will be able to change it.  */
  4518           NILP (prop) && IT_CHARPOS (*it) < Z))
  4519     {
  4520       specpdl_ref count = SPECPDL_INDEX ();
  4521       Lisp_Object val;
  4522       struct buffer *obuf = current_buffer;
  4523       ptrdiff_t begv = BEGV, zv = ZV;
  4524       bool old_clip_changed = current_buffer->clip_changed;
  4525       bool saved_inhibit_flag = it->f->inhibit_clear_image_cache;
  4526 
  4527       val = Vfontification_functions;
  4528       specbind (Qfontification_functions, Qnil);
  4529 
  4530       eassert (it->end_charpos == ZV);
  4531 
  4532       if (current_buffer->long_line_optimizations_p
  4533           && long_line_optimizations_region_size > 0)
  4534         {
  4535           ptrdiff_t begv = it->large_narrowing_begv;
  4536           ptrdiff_t zv = it->large_narrowing_zv;
  4537           ptrdiff_t charpos = IT_CHARPOS (*it);
  4538           if (charpos < begv || charpos > zv)
  4539             {
  4540               begv = get_large_narrowing_begv (charpos);
  4541               zv = get_large_narrowing_zv (charpos);
  4542             }
  4543           if (begv != BEG || zv != Z)
  4544             labeled_narrow_to_region (make_fixnum (begv), make_fixnum (zv),
  4545                                       Qlong_line_optimizations_in_fontification_functions);
  4546         }
  4547 
  4548       /* Don't allow Lisp that runs from 'fontification-functions'
  4549          clear our face and image caches behind our back.  */
  4550       it->f->inhibit_clear_image_cache = true;
  4551 
  4552       if (!CONSP (val) || EQ (XCAR (val), Qlambda))
  4553         safe_call1 (val, pos);
  4554       else
  4555         {
  4556           Lisp_Object fns, fn;
  4557 
  4558           fns = Qnil;
  4559 
  4560           for (; CONSP (val); val = XCDR (val))
  4561             {
  4562               fn = XCAR (val);
  4563 
  4564               if (EQ (fn, Qt))
  4565                 {
  4566                   /* A value of t indicates this hook has a local
  4567                      binding; it means to run the global binding too.
  4568                      In a global value, t should not occur.  If it
  4569                      does, we must ignore it to avoid an endless
  4570                      loop.  */
  4571                   for (fns = Fdefault_value (Qfontification_functions);
  4572                        CONSP (fns);
  4573                        fns = XCDR (fns))
  4574                     {
  4575                       fn = XCAR (fns);
  4576                       if (!EQ (fn, Qt))
  4577                         safe_call1 (fn, pos);
  4578                     }
  4579                 }
  4580               else
  4581                 safe_call1 (fn, pos);
  4582             }
  4583         }
  4584 
  4585       it->f->inhibit_clear_image_cache = saved_inhibit_flag;
  4586       unbind_to (count, Qnil);
  4587 
  4588       /* Fontification functions routinely call `save-restriction'.
  4589          Normally, this tags clip_changed, which can confuse redisplay
  4590          (see discussion in Bug#6671).  Since we don't perform any
  4591          special handling of fontification changes in the case where
  4592          `save-restriction' isn't called, there's no point doing so in
  4593          this case either.  So, if the buffer's restrictions are
  4594          actually left unchanged, reset clip_changed.  */
  4595       if (obuf == current_buffer)
  4596         {
  4597           if (begv == BEGV && zv == ZV)
  4598             current_buffer->clip_changed = old_clip_changed;
  4599         }
  4600       /* There isn't much we can reasonably do to protect against
  4601          misbehaving fontification, but here's a fig leaf.  */
  4602       else if (BUFFER_LIVE_P (obuf))
  4603         set_buffer_internal_1 (obuf);
  4604 
  4605       /* The fontification code may have added/removed text.
  4606          It could do even a lot worse, but let's at least protect against
  4607          the most obvious case where only the text past `pos' gets changed',
  4608          as is/was done in grep.el where some escapes sequences are turned
  4609          into face properties (bug#7876).  */
  4610       it->end_charpos = ZV;
  4611 
  4612       /* Return HANDLED_RECOMPUTE_PROPS only if function fontified
  4613          something.  This avoids an endless loop if they failed to
  4614          fontify the text for which reason ever.  */
  4615       if (!NILP (Fget_char_property (pos, Qfontified, Qnil)))
  4616         handled = HANDLED_RECOMPUTE_PROPS;
  4617     }
  4618 
  4619   return handled;
  4620 }
  4621 
  4622 
  4623 
  4624 /***********************************************************************
  4625                                 Faces
  4626  ***********************************************************************/
  4627 
  4628 static int
  4629 face_at_pos (const struct it *it, enum lface_attribute_index attr_filter)
  4630 {
  4631   ptrdiff_t next_stop;
  4632 
  4633   if (!STRINGP (it->string))
  4634     {
  4635       return face_at_buffer_position (it->w,
  4636                                       IT_CHARPOS (*it),
  4637                                       &next_stop,
  4638                                       (IT_CHARPOS (*it)
  4639                                        + TEXT_PROP_DISTANCE_LIMIT),
  4640                                       false, it->base_face_id,
  4641                                       attr_filter);
  4642     }
  4643   else
  4644     {
  4645       int base_face_id;
  4646       ptrdiff_t bufpos;
  4647       int i;
  4648       Lisp_Object from_overlay
  4649         = (it->current.overlay_string_index >= 0
  4650            ? it->string_overlays[it->current.overlay_string_index
  4651                                  % OVERLAY_STRING_CHUNK_SIZE]
  4652            : Qnil);
  4653 
  4654       /* See if we got to this string directly or indirectly from
  4655          an overlay property.  That includes the before-string or
  4656          after-string of an overlay, strings in display properties
  4657          provided by an overlay, their text properties, etc.
  4658 
  4659          FROM_OVERLAY is the overlay that brought us here, or nil if none.  */
  4660       if (! NILP (from_overlay))
  4661         for (i = it->sp - 1; i >= 0; i--)
  4662           {
  4663             if (it->stack[i].current.overlay_string_index >= 0)
  4664               from_overlay
  4665                 = it->string_overlays[it->stack[i].current.overlay_string_index
  4666                                       % OVERLAY_STRING_CHUNK_SIZE];
  4667             else if (! NILP (it->stack[i].from_overlay))
  4668               from_overlay = it->stack[i].from_overlay;
  4669 
  4670             if (!NILP (from_overlay))
  4671               break;
  4672           }
  4673 
  4674       if (! NILP (from_overlay))
  4675         {
  4676           bufpos = IT_CHARPOS (*it);
  4677           /* For a string from an overlay, the base face depends
  4678              only on text properties and ignores overlays.  */
  4679           base_face_id
  4680             = face_for_overlay_string (it->w,
  4681                                        IT_CHARPOS (*it),
  4682                                        &next_stop,
  4683                                        (IT_CHARPOS (*it)
  4684                                         + TEXT_PROP_DISTANCE_LIMIT),
  4685                                        false,
  4686                                        from_overlay, attr_filter);
  4687         }
  4688       else
  4689         {
  4690           bufpos = 0;
  4691 
  4692           /* For strings from a `display' property, use the face at
  4693              IT's current buffer position as the base face to merge
  4694              with, so that overlay strings appear in the same face as
  4695              surrounding text, unless they specify their own faces.
  4696              For strings from wrap-prefix and line-prefix properties,
  4697              use the default face, possibly remapped via
  4698              Vface_remapping_alist.  */
  4699           /* Note that the fact that we use the face at _buffer_
  4700              position means that a 'display' property on an overlay
  4701              string will not inherit the face of that overlay string,
  4702              but will instead revert to the face of buffer text
  4703              covered by the overlay.  This is visible, e.g., when the
  4704              overlay specifies a box face, but neither the buffer nor
  4705              the display string do.  This sounds like a design bug,
  4706              but Emacs always did that since v21.1, so changing that
  4707              might be a big deal.  */
  4708           base_face_id = it->string_from_prefix_prop_p
  4709             ? (!NILP (Vface_remapping_alist)
  4710                ? lookup_basic_face (it->w, it->f, DEFAULT_FACE_ID)
  4711                : DEFAULT_FACE_ID)
  4712             : underlying_face_id (it);
  4713         }
  4714 
  4715       return face_at_string_position (it->w,
  4716                                       it->string,
  4717                                       IT_STRING_CHARPOS (*it),
  4718                                       bufpos,
  4719                                       &next_stop,
  4720                                       base_face_id, false,
  4721                                       attr_filter);
  4722     } /* !STRINGP (it->string) */
  4723 }
  4724 
  4725 
  4726 /* Set up iterator IT from face properties at its current position.
  4727    Called from handle_stop.  */
  4728 static enum prop_handled
  4729 handle_face_prop (struct it *it)
  4730 {
  4731   specpdl_ref count = SPECPDL_INDEX ();
  4732   /* Don't allow the user to quit out of face-merging code, in case
  4733      this is called when redisplaying a non-selected window, with
  4734      point temporarily moved to window-point.  */
  4735   specbind (Qinhibit_quit, Qt);
  4736   const int new_face_id = face_at_pos (it, 0);
  4737   unbind_to (count, Qnil);
  4738 
  4739 
  4740   /* Is this a start of a run of characters with box face?
  4741      Caveat: this can be called for a freshly initialized
  4742      iterator; face_id is -1 in this case.  We know that the new
  4743      face will not change until limit, i.e. if the new face has a
  4744      box, all characters up to limit will have one.  But, as
  4745      usual, we don't know whether limit is really the end.  */
  4746   if (new_face_id != it->face_id)
  4747     {
  4748       struct face *new_face = FACE_FROM_ID (it->f, new_face_id);
  4749       /* If it->face_id is -1, old_face below will be NULL, see
  4750          the definition of FACE_FROM_ID_OR_NULL.  This will happen
  4751          if this is the initial call that gets the face.  */
  4752       struct face *old_face = FACE_FROM_ID_OR_NULL (it->f, it->face_id);
  4753 
  4754       /* If the value of face_id of the iterator is -1, we have to
  4755          look in front of IT's position and see whether there is a
  4756          face there that's different from new_face_id.  */
  4757       if (!STRINGP (it->string)
  4758           && !old_face
  4759           && IT_CHARPOS (*it) > BEG)
  4760         {
  4761           const int prev_face_id = face_before_it_pos (it);
  4762 
  4763           old_face = FACE_FROM_ID_OR_NULL (it->f, prev_face_id);
  4764         }
  4765 
  4766       /* If the new face has a box, but the old face does not,
  4767          this is the start of a run of characters with box face,
  4768          i.e. this character has a shadow on the left side.  */
  4769       it->face_id = new_face_id;
  4770       /* Don't reset the start_of_box_run_p flag, only set it if
  4771          needed.  */
  4772       if (!(it->start_of_box_run_p && old_face && old_face->box))
  4773         it->start_of_box_run_p = (new_face->box != FACE_NO_BOX
  4774                                   && (old_face == NULL || !old_face->box));
  4775       it->face_box_p = new_face->box != FACE_NO_BOX;
  4776     }
  4777 
  4778   return HANDLED_NORMALLY;
  4779 }
  4780 
  4781 
  4782 /* Return the ID of the face ``underlying'' IT's current position,
  4783    which is in a string.  If the iterator is associated with a
  4784    buffer, return the face at IT's current buffer position.
  4785    Otherwise, use the iterator's base_face_id.  */
  4786 
  4787 static int
  4788 underlying_face_id (const struct it *it)
  4789 {
  4790   int face_id = it->base_face_id, i;
  4791 
  4792   eassert (STRINGP (it->string));
  4793 
  4794   for (i = it->sp - 1; i >= 0; --i)
  4795     if (NILP (it->stack[i].string))
  4796       face_id = it->stack[i].face_id;
  4797 
  4798   return face_id;
  4799 }
  4800 
  4801 
  4802 /* Compute the face one character before or after the current position
  4803    of IT, in the visual order.  BEFORE_P means get the face
  4804    in front (to the left in L2R paragraphs, to the right in R2L
  4805    paragraphs) of IT's screen position.  Value is the ID of the face.  */
  4806 
  4807 static int
  4808 face_before_or_after_it_pos (struct it *it, bool before_p)
  4809 {
  4810   int face_id, limit;
  4811   ptrdiff_t next_check_charpos;
  4812   struct it it_copy;
  4813   void *it_copy_data = NULL;
  4814 
  4815   eassert (it->s == NULL);
  4816 
  4817   if (STRINGP (it->string))
  4818     {
  4819       ptrdiff_t bufpos, charpos;
  4820       int base_face_id;
  4821 
  4822       /* No face change past the end of the string (for the case we
  4823          are padding with spaces).  No face change before the string
  4824          start.  Ignore face changes before the first visible
  4825          character on this display line.  */
  4826       if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string)
  4827           || (IT_STRING_CHARPOS (*it) == 0 && before_p)
  4828           || it->current_x <= it->first_visible_x)
  4829         return it->face_id;
  4830 
  4831       if (!it->bidi_p)
  4832         {
  4833           /* Set charpos to the position before or after IT's current
  4834              position, in the logical order, which in the non-bidi
  4835              case is the same as the visual order.  */
  4836           if (before_p)
  4837             charpos = IT_STRING_CHARPOS (*it) - 1;
  4838           else if (it->what == IT_COMPOSITION)
  4839             /* For composition, we must check the character after the
  4840                composition.  */
  4841             charpos = IT_STRING_CHARPOS (*it) + it->cmp_it.nchars;
  4842           else
  4843             charpos = IT_STRING_CHARPOS (*it) + 1;
  4844         }
  4845       else
  4846         {
  4847           /* With bidi iteration, the character before the current in
  4848              the visual order cannot be found by simple iteration,
  4849              because "reverse" reordering is not supported.  Instead,
  4850              we need to start from the string beginning and go all the
  4851              way to the current string position, remembering the
  4852              visually-previous position.  We need to start from the
  4853              string beginning for the character after the current as
  4854              well, since the iterator state in IT may have been
  4855              pushed, and the bidi cache is no longer coherent with the
  4856              string's text.  */
  4857           SAVE_IT (it_copy, *it, it_copy_data);
  4858           IT_STRING_CHARPOS (it_copy) = 0;
  4859           bidi_init_it (0, 0, FRAME_WINDOW_P (it_copy.f), &it_copy.bidi_it);
  4860           it_copy.bidi_it.scan_dir = 0;
  4861 
  4862           do
  4863             {
  4864               charpos = it_copy.bidi_it.charpos;
  4865               if (charpos >= SCHARS (it->string))
  4866                 break;
  4867               bidi_move_to_visually_next (&it_copy.bidi_it);
  4868             }
  4869           while (it_copy.bidi_it.charpos != IT_STRING_CHARPOS (*it));
  4870 
  4871           if (!before_p)
  4872             {
  4873               /* Set charpos to the string position of the character
  4874                  that comes after IT's current position in the visual
  4875                  order.  */
  4876               int n = (it->what == IT_COMPOSITION ? it->cmp_it.nchars : 1);
  4877               /* If this is the first string character,
  4878                  bidi_move_to_visually_next will deliver character at
  4879                  current position without moving, so we need to enlarge N.  */
  4880               if (it_copy.bidi_it.first_elt)
  4881                 n++;
  4882               while (n--)
  4883                 bidi_move_to_visually_next (&it_copy.bidi_it);
  4884 
  4885               charpos = it_copy.bidi_it.charpos;
  4886             }
  4887 
  4888           RESTORE_IT (it, it, it_copy_data);
  4889         }
  4890       eassert (0 <= charpos && charpos <= SCHARS (it->string));
  4891 
  4892       if (it->current.overlay_string_index >= 0)
  4893         bufpos = IT_CHARPOS (*it);
  4894       else
  4895         bufpos = 0;
  4896 
  4897       base_face_id = underlying_face_id (it);
  4898 
  4899       /* Get the face for ASCII, or unibyte.  */
  4900       face_id = face_at_string_position (it->w, it->string, charpos,
  4901                                          bufpos, &next_check_charpos,
  4902                                          base_face_id, false, 0);
  4903 
  4904       /* Correct the face for charsets different from ASCII.  Do it
  4905          for the multibyte case only.  The face returned above is
  4906          suitable for unibyte text if IT->string is unibyte.  */
  4907       if (STRING_MULTIBYTE (it->string))
  4908         {
  4909           struct text_pos pos1 = string_pos (charpos, it->string);
  4910           const unsigned char *p = SDATA (it->string) + BYTEPOS (pos1);
  4911           struct face *face = FACE_FROM_ID (it->f, face_id);
  4912           int len, c = check_char_and_length (p, &len);
  4913           face_id = FACE_FOR_CHAR (it->f, face, c, charpos, it->string);
  4914         }
  4915     }
  4916   else
  4917     {
  4918       struct text_pos pos;
  4919 
  4920       if ((IT_CHARPOS (*it) >= ZV && !before_p)
  4921           || (IT_CHARPOS (*it) <= BEGV && before_p))
  4922         return it->face_id;
  4923 
  4924       limit = IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT;
  4925       pos = it->current.pos;
  4926 
  4927       if (!it->bidi_p)
  4928         {
  4929           if (before_p)
  4930             DEC_TEXT_POS (pos, it->multibyte_p);
  4931           else
  4932             {
  4933               if (it->what == IT_COMPOSITION)
  4934                 {
  4935                   /* For composition, we must check the position after
  4936                      the composition.  */
  4937                   pos.charpos += it->cmp_it.nchars;
  4938                   pos.bytepos += it->len;
  4939                 }
  4940               else
  4941                 INC_TEXT_POS (pos, it->multibyte_p);
  4942             }
  4943         }
  4944       else
  4945         {
  4946           if (before_p)
  4947             {
  4948               int current_x;
  4949 
  4950               /* With bidi iteration, the character before the current
  4951                  in the visual order cannot be found by simple
  4952                  iteration, because "reverse" reordering is not
  4953                  supported.  Instead, we need to use the move_it_*
  4954                  family of functions, and move to the previous
  4955                  character starting from the beginning of the visual
  4956                  line.  */
  4957               /* Ignore face changes before the first visible
  4958                  character on this display line.  */
  4959               if (it->current_x <= it->first_visible_x)
  4960                 return it->face_id;
  4961               SAVE_IT (it_copy, *it, it_copy_data);
  4962               /* Implementation note: Since move_it_in_display_line
  4963                  works in the iterator geometry, and thinks the first
  4964                  character is always the leftmost, even in R2L lines,
  4965                  we don't need to distinguish between the R2L and L2R
  4966                  cases here.  */
  4967               current_x = it_copy.current_x;
  4968               move_it_vertically_backward (&it_copy, 0);
  4969               move_it_in_display_line (&it_copy, ZV, current_x - 1, MOVE_TO_X);
  4970               pos = it_copy.current.pos;
  4971               RESTORE_IT (it, it, it_copy_data);
  4972             }
  4973           else
  4974             {
  4975               /* Set charpos to the buffer position of the character
  4976                  that comes after IT's current position in the visual
  4977                  order.  */
  4978               int n = (it->what == IT_COMPOSITION ? it->cmp_it.nchars : 1);
  4979 
  4980               it_copy = *it;
  4981               /* If this is the first display element,
  4982                  bidi_move_to_visually_next will deliver character at
  4983                  current position without moving, so we need to enlarge N.  */
  4984               if (it->bidi_it.first_elt)
  4985                 n++;
  4986               while (n--)
  4987                 bidi_move_to_visually_next (&it_copy.bidi_it);
  4988 
  4989               SET_TEXT_POS (pos,
  4990                             it_copy.bidi_it.charpos, it_copy.bidi_it.bytepos);
  4991             }
  4992         }
  4993       eassert (BEGV <= CHARPOS (pos) && CHARPOS (pos) <= ZV);
  4994 
  4995       /* Determine face for CHARSET_ASCII, or unibyte.  */
  4996       face_id = face_at_buffer_position (it->w,
  4997                                          CHARPOS (pos),
  4998                                          &next_check_charpos,
  4999                                          limit, false, -1, 0);
  5000 
  5001       /* Correct the face for charsets different from ASCII.  Do it
  5002          for the multibyte case only.  The face returned above is
  5003          suitable for unibyte text if current_buffer is unibyte.  */
  5004       if (it->multibyte_p)
  5005         {
  5006           int c = FETCH_MULTIBYTE_CHAR (BYTEPOS (pos));
  5007           struct face *face = FACE_FROM_ID (it->f, face_id);
  5008           face_id = FACE_FOR_CHAR (it->f, face, c, CHARPOS (pos), Qnil);
  5009         }
  5010     }
  5011 
  5012   return face_id;
  5013 }
  5014 
  5015 
  5016 
  5017 /***********************************************************************
  5018                             Invisible text
  5019  ***********************************************************************/
  5020 
  5021 /* Set up iterator IT from invisible properties at its current
  5022    position.  Called from handle_stop.  */
  5023 
  5024 static enum prop_handled
  5025 handle_invisible_prop (struct it *it)
  5026 {
  5027   enum prop_handled handled = HANDLED_NORMALLY;
  5028   int invis;
  5029   Lisp_Object prop;
  5030 
  5031   if (STRINGP (it->string))
  5032     {
  5033       Lisp_Object end_charpos, limit;
  5034 
  5035       /* Get the value of the invisible text property at the
  5036          current position.  Value will be nil if there is no such
  5037          property.  */
  5038       end_charpos = make_fixnum (IT_STRING_CHARPOS (*it));
  5039       prop = Fget_text_property (end_charpos, Qinvisible, it->string);
  5040       invis = TEXT_PROP_MEANS_INVISIBLE (prop);
  5041 
  5042       if (invis != 0 && IT_STRING_CHARPOS (*it) < it->end_charpos)
  5043         {
  5044           /* Record whether we have to display an ellipsis for the
  5045              invisible text.  */
  5046           bool display_ellipsis_p = (invis == 2);
  5047           ptrdiff_t len, endpos;
  5048 
  5049           handled = HANDLED_RECOMPUTE_PROPS;
  5050 
  5051           /* Get the position at which the next visible text can be
  5052              found in IT->string, if any.  */
  5053           endpos = len = SCHARS (it->string);
  5054           XSETINT (limit, len);
  5055           do
  5056             {
  5057               end_charpos
  5058                 = Fnext_single_property_change (end_charpos, Qinvisible,
  5059                                                 it->string, limit);
  5060               /* Since LIMIT is always an integer, so should be the
  5061                  value returned by Fnext_single_property_change.  */
  5062               eassert (FIXNUMP (end_charpos));
  5063               if (FIXNUMP (end_charpos))
  5064                 {
  5065                   endpos = XFIXNAT (end_charpos);
  5066                   prop = Fget_text_property (end_charpos, Qinvisible, it->string);
  5067                   invis = TEXT_PROP_MEANS_INVISIBLE (prop);
  5068                   if (invis == 2)
  5069                     display_ellipsis_p = true;
  5070                 }
  5071               else /* Should never happen; but if it does, exit the loop.  */
  5072                 endpos = len;
  5073             }
  5074           while (invis != 0 && endpos < len);
  5075 
  5076           if (display_ellipsis_p)
  5077             it->ellipsis_p = true;
  5078 
  5079           if (endpos < len)
  5080             {
  5081               /* Text at END_CHARPOS is visible.  Move IT there.  */
  5082               struct text_pos old;
  5083               ptrdiff_t oldpos;
  5084 
  5085               old = it->current.string_pos;
  5086               oldpos = CHARPOS (old);
  5087               if (it->bidi_p)
  5088                 {
  5089                   if (it->bidi_it.first_elt
  5090                       && it->bidi_it.charpos < SCHARS (it->string))
  5091                     bidi_paragraph_init (it->paragraph_embedding,
  5092                                          &it->bidi_it, true);
  5093                   /* Bidi-iterate out of the invisible text.  */
  5094                   do
  5095                     {
  5096                       bidi_move_to_visually_next (&it->bidi_it);
  5097                     }
  5098                   while (oldpos <= it->bidi_it.charpos
  5099                          && it->bidi_it.charpos < endpos
  5100                          && it->bidi_it.charpos < it->bidi_it.string.schars);
  5101 
  5102                   IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
  5103                   IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
  5104                   if (IT_CHARPOS (*it) >= endpos)
  5105                     it->prev_stop = endpos;
  5106                 }
  5107               else
  5108                 {
  5109                   IT_STRING_CHARPOS (*it) = endpos;
  5110                   compute_string_pos (&it->current.string_pos, old, it->string);
  5111                 }
  5112             }
  5113           else
  5114             {
  5115               /* The rest of the string is invisible.  If this is an
  5116                  overlay string, proceed with the next overlay string
  5117                  or whatever comes and return a character from there.  */
  5118               if (it->current.overlay_string_index >= 0
  5119                   && !display_ellipsis_p)
  5120                 {
  5121                   next_overlay_string (it);
  5122                   /* Don't check for overlay strings when we just
  5123                      finished processing them.  */
  5124                   handled = HANDLED_OVERLAY_STRING_CONSUMED;
  5125                 }
  5126               else
  5127                 {
  5128                   IT_STRING_CHARPOS (*it) = SCHARS (it->string);
  5129                   IT_STRING_BYTEPOS (*it) = SBYTES (it->string);
  5130                 }
  5131             }
  5132         }
  5133     }
  5134   else
  5135     {
  5136       ptrdiff_t newpos, next_stop, start_charpos, tem;
  5137       Lisp_Object pos, overlay;
  5138 
  5139       /* First of all, is there invisible text at this position?  */
  5140       tem = start_charpos = IT_CHARPOS (*it);
  5141       pos = make_fixnum (tem);
  5142       prop = get_char_property_and_overlay (pos, Qinvisible, it->window,
  5143                                             &overlay);
  5144       invis = TEXT_PROP_MEANS_INVISIBLE (prop);
  5145 
  5146       /* If we are on invisible text, skip over it.  */
  5147       if (invis != 0 && start_charpos < it->end_charpos)
  5148         {
  5149           /* Record whether we have to display an ellipsis for the
  5150              invisible text.  */
  5151           bool display_ellipsis_p = invis == 2;
  5152 
  5153           handled = HANDLED_RECOMPUTE_PROPS;
  5154 
  5155           /* Loop skipping over invisible text.  The loop is left at
  5156              ZV or with IT on the first char being visible again.  */
  5157           do
  5158             {
  5159               /* Try to skip some invisible text.  Return value is the
  5160                  position reached which can be equal to where we start
  5161                  if there is nothing invisible there.  This skips both
  5162                  over invisible text properties and overlays with
  5163                  invisible property.  */
  5164               newpos = skip_invisible (tem, &next_stop, ZV, it->window);
  5165 
  5166               /* If we skipped nothing at all we weren't at invisible
  5167                  text in the first place.  If everything to the end of
  5168                  the buffer was skipped, end the loop.  */
  5169               if (newpos == tem || newpos >= ZV)
  5170                 invis = 0;
  5171               else
  5172                 {
  5173                   /* We skipped some characters but not necessarily
  5174                      all there are.  Check if we ended up on visible
  5175                      text.  Fget_char_property returns the property of
  5176                      the char before the given position, i.e. if we
  5177                      get invis = 0, this means that the char at
  5178                      newpos is visible.  */
  5179                   pos = make_fixnum (newpos);
  5180                   prop = Fget_char_property (pos, Qinvisible, it->window);
  5181                   invis = TEXT_PROP_MEANS_INVISIBLE (prop);
  5182                 }
  5183 
  5184               /* If we ended up on invisible text, proceed to
  5185                  skip starting with next_stop.  */
  5186               if (invis != 0)
  5187                 tem = next_stop;
  5188 
  5189               /* If there are adjacent invisible texts, don't lose the
  5190                  second one's ellipsis.  */
  5191               if (invis == 2)
  5192                 display_ellipsis_p = true;
  5193             }
  5194           while (invis != 0);
  5195 
  5196           /* The position newpos is now either ZV or on visible text.  */
  5197           if (it->bidi_p)
  5198             {
  5199               ptrdiff_t bpos = CHAR_TO_BYTE (newpos);
  5200               bool on_newline
  5201                 = bpos == ZV_BYTE || FETCH_BYTE (bpos) == '\n';
  5202               bool after_newline
  5203                 = newpos <= BEGV || FETCH_BYTE (bpos - 1) == '\n';
  5204 
  5205               /* If the invisible text ends on a newline or on a
  5206                  character after a newline, we can avoid the costly,
  5207                  character by character, bidi iteration to NEWPOS, and
  5208                  instead simply reseat the iterator there.  That's
  5209                  because all bidi reordering information is tossed at
  5210                  the newline.  This is a big win for modes that hide
  5211                  complete lines, like Outline, Org, etc.  */
  5212               if (on_newline || after_newline)
  5213                 {
  5214                   struct text_pos tpos;
  5215                   bidi_dir_t pdir = it->bidi_it.paragraph_dir;
  5216 
  5217                   SET_TEXT_POS (tpos, newpos, bpos);
  5218                   reseat_1 (it, tpos, false);
  5219                   /* If we reseat on a newline/ZV, we need to prep the
  5220                      bidi iterator for advancing to the next character
  5221                      after the newline/EOB, keeping the current paragraph
  5222                      direction (so that PRODUCE_GLYPHS does TRT wrt
  5223                      prepending/appending glyphs to a glyph row).  */
  5224                   if (on_newline)
  5225                     {
  5226                       it->bidi_it.first_elt = false;
  5227                       it->bidi_it.paragraph_dir = pdir;
  5228                       it->bidi_it.ch = (bpos == ZV_BYTE) ? -1 : '\n';
  5229                       it->bidi_it.nchars = 1;
  5230                       it->bidi_it.ch_len = 1;
  5231                     }
  5232                 }
  5233               else      /* Must use the slow method.  */
  5234                 {
  5235                   /* With bidi iteration, the region of invisible text
  5236                      could start and/or end in the middle of a
  5237                      non-base embedding level.  Therefore, we need to
  5238                      skip invisible text using the bidi iterator,
  5239                      starting at IT's current position, until we find
  5240                      ourselves outside of the invisible text.
  5241                      Skipping invisible text _after_ bidi iteration
  5242                      avoids affecting the visual order of the
  5243                      displayed text when invisible properties are
  5244                      added or removed.  */
  5245                   if (it->bidi_it.first_elt && it->bidi_it.charpos < ZV)
  5246                     {
  5247                       /* If we were `reseat'ed to a new paragraph,
  5248                          determine the paragraph base direction.  We
  5249                          need to do it now because
  5250                          next_element_from_buffer may not have a
  5251                          chance to do it, if we are going to skip any
  5252                          text at the beginning, which resets the
  5253                          FIRST_ELT flag.  */
  5254                       bidi_paragraph_init (it->paragraph_embedding,
  5255                                            &it->bidi_it, true);
  5256                     }
  5257                   do
  5258                     {
  5259                       bidi_move_to_visually_next (&it->bidi_it);
  5260                     }
  5261                   while (it->stop_charpos <= it->bidi_it.charpos
  5262                          && it->bidi_it.charpos < newpos);
  5263                   IT_CHARPOS (*it) = it->bidi_it.charpos;
  5264                   IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  5265                   /* If we overstepped NEWPOS, record its position in
  5266                      the iterator, so that we skip invisible text if
  5267                      later the bidi iteration lands us in the
  5268                      invisible region again. */
  5269                   if (IT_CHARPOS (*it) >= newpos)
  5270                     it->prev_stop = newpos;
  5271                 }
  5272             }
  5273           else
  5274             {
  5275               IT_CHARPOS (*it) = newpos;
  5276               IT_BYTEPOS (*it) = CHAR_TO_BYTE (newpos);
  5277             }
  5278 
  5279           if (display_ellipsis_p)
  5280             {
  5281               /* Make sure that the glyphs of the ellipsis will get
  5282                  correct `charpos' values.  If we would not update
  5283                  it->position here, the glyphs would belong to the
  5284                  last visible character _before_ the invisible
  5285                  text, which confuses `set_cursor_from_row'.
  5286 
  5287                  We use the last invisible position instead of the
  5288                  first because this way the cursor is always drawn on
  5289                  the first "." of the ellipsis, whenever PT is inside
  5290                  the invisible text.  Otherwise the cursor would be
  5291                  placed _after_ the ellipsis when the point is after the
  5292                  first invisible character.  */
  5293               if (!STRINGP (it->object))
  5294                 {
  5295                   it->position.charpos = newpos - 1;
  5296                   it->position.bytepos = CHAR_TO_BYTE (it->position.charpos);
  5297                 }
  5298             }
  5299 
  5300           /* If there are before-strings at the start of invisible
  5301              text, and the text is invisible because of a text
  5302              property, arrange to show before-strings because 20.x did
  5303              it that way.  (If the text is invisible because of an
  5304              overlay property instead of a text property, this is
  5305              already handled in the overlay code.)  */
  5306           if (NILP (overlay)
  5307               && get_overlay_strings (it, it->stop_charpos))
  5308             {
  5309               handled = HANDLED_RECOMPUTE_PROPS;
  5310               if (it->sp > 0)
  5311                 {
  5312                   it->stack[it->sp - 1].display_ellipsis_p = display_ellipsis_p;
  5313                   /* The call to get_overlay_strings above recomputes
  5314                      it->stop_charpos, but it only considers changes
  5315                      in properties and overlays beyond iterator's
  5316                      current position.  This causes us to miss changes
  5317                      that happen exactly where the invisible property
  5318                      ended.  So we play it safe here and force the
  5319                      iterator to check for potential stop positions
  5320                      immediately after the invisible text.  Note that
  5321                      if get_overlay_strings returns true, it
  5322                      normally also pushed the iterator stack, so we
  5323                      need to update the stop position in the slot
  5324                      below the current one.  */
  5325                   it->stack[it->sp - 1].stop_charpos
  5326                     = CHARPOS (it->stack[it->sp - 1].current.pos);
  5327                 }
  5328             }
  5329           else if (display_ellipsis_p)
  5330             {
  5331               it->ellipsis_p = true;
  5332               /* Let the ellipsis display before
  5333                  considering any properties of the following char.
  5334                  Fixes jasonr@gnu.org 01 Oct 07 bug.  */
  5335               handled = HANDLED_RETURN;
  5336             }
  5337         }
  5338     }
  5339 
  5340   return handled;
  5341 }
  5342 
  5343 
  5344 /* Make iterator IT return `...' next.
  5345    Replaces LEN characters from buffer.  */
  5346 
  5347 static void
  5348 setup_for_ellipsis (struct it *it, int len)
  5349 {
  5350   /* Use the display table definition for `...'.  Invalid glyphs
  5351      will be handled by the method returning elements from dpvec.  */
  5352   if (it->dp && VECTORP (DISP_INVIS_VECTOR (it->dp)))
  5353     {
  5354       struct Lisp_Vector *v = XVECTOR (DISP_INVIS_VECTOR (it->dp));
  5355       it->dpvec = v->contents;
  5356       it->dpend = v->contents + v->header.size;
  5357     }
  5358   else
  5359     {
  5360       /* Default `...'.  */
  5361       it->dpvec = default_invis_vector;
  5362       it->dpend = default_invis_vector + 3;
  5363     }
  5364 
  5365   it->dpvec_char_len = len;
  5366   it->current.dpvec_index = 0;
  5367   it->dpvec_face_id = -1;
  5368 
  5369   /* Use IT->saved_face_id for the ellipsis, so that it has the same
  5370      face as the preceding text.  IT->saved_face_id was set in
  5371      handle_stop to the face of the preceding character, and will be
  5372      different from IT->face_id only if the invisible text skipped in
  5373      handle_invisible_prop has some non-default face on its first
  5374      character.  We thus ignore the face of the invisible text when we
  5375      display the ellipsis.  IT's face is restored in set_iterator_to_next.  */
  5376   if (it->saved_face_id >= 0)
  5377     it->face_id = it->saved_face_id;
  5378 
  5379   /* If the ellipsis represents buffer text, it means we advanced in
  5380      the buffer, so we should no longer ignore overlay strings.  */
  5381   if (it->method == GET_FROM_BUFFER)
  5382     it->ignore_overlay_strings_at_pos_p = false;
  5383 
  5384   it->method = GET_FROM_DISPLAY_VECTOR;
  5385   it->ellipsis_p = true;
  5386 }
  5387 
  5388 
  5389 static Lisp_Object
  5390 find_display_property (Lisp_Object disp, Lisp_Object prop)
  5391 {
  5392   if (NILP (disp))
  5393     return Qnil;
  5394   /* We have a vector of display specs.  */
  5395   if (VECTORP (disp))
  5396     {
  5397       for (ptrdiff_t i = 0; i < ASIZE (disp); i++)
  5398         {
  5399           Lisp_Object elem = AREF (disp, i);
  5400           if (CONSP (elem)
  5401               && CONSP (XCDR (elem))
  5402               && EQ (XCAR (elem), prop))
  5403             return XCAR (XCDR (elem));
  5404         }
  5405       return Qnil;
  5406     }
  5407   /* We have a list of display specs.  */
  5408   else if (CONSP (disp)
  5409            && CONSP (XCAR (disp)))
  5410     {
  5411       while (!NILP (disp))
  5412         {
  5413           Lisp_Object elem = XCAR (disp);
  5414           if (CONSP (elem)
  5415               && CONSP (XCDR (elem))
  5416               && EQ (XCAR (elem), prop))
  5417             return XCAR (XCDR (elem));
  5418 
  5419           /* Check that we have a proper list before going to the next
  5420              element.  */
  5421           if (CONSP (XCDR (disp)))
  5422             disp = XCDR (disp);
  5423           else
  5424             disp = Qnil;
  5425         }
  5426       return Qnil;
  5427     }
  5428   /* A simple display spec.  */
  5429   else if (CONSP (disp)
  5430            && CONSP (XCDR (disp))
  5431            && EQ (XCAR (disp), prop))
  5432     return XCAR (XCDR (disp));
  5433   else
  5434     return Qnil;
  5435 }
  5436 
  5437 static Lisp_Object
  5438 get_display_property (ptrdiff_t bufpos, Lisp_Object prop, Lisp_Object object)
  5439 {
  5440   return find_display_property (Fget_text_property (make_fixnum (bufpos),
  5441                                                     Qdisplay, object),
  5442                                 prop);
  5443 }
  5444 
  5445 static void
  5446 display_min_width (struct it *it, ptrdiff_t bufpos,
  5447                    Lisp_Object object, Lisp_Object width_spec)
  5448 {
  5449   /* We're being called at the end of the `min-width' sequence,
  5450      probably. */
  5451   if (!NILP (it->min_width_property)
  5452       && !EQ (width_spec, it->min_width_property))
  5453     {
  5454       if (!it->glyph_row)
  5455         return;
  5456 
  5457       /* When called from display_string (i.e., the mode line),
  5458          we're being called with a string as the object, and we
  5459          may be called with many sub-strings belonging to the same
  5460          :propertize run. */
  5461       if ((bufpos == 0
  5462            && !EQ (it->min_width_property,
  5463                    get_display_property (0, Qmin_width, object)))
  5464           /* In a buffer -- check that we're really right after the
  5465              sequence of characters covered by this `min-width'.  */
  5466           || (bufpos > BEGV
  5467               && EQ (it->min_width_property,
  5468                      get_display_property (bufpos - 1, Qmin_width, object))))
  5469         {
  5470           Lisp_Object w = Qnil;
  5471           double width;
  5472 #ifdef HAVE_WINDOW_SYSTEM
  5473           if (FRAME_WINDOW_P (it->f))
  5474             {
  5475               struct font *font = NULL;
  5476               struct face *face = FACE_FROM_ID (it->f, it->face_id);
  5477               font = face->font ? face->font : FRAME_FONT (it->f);
  5478               calc_pixel_width_or_height (&width, it,
  5479                                           XCAR (it->min_width_property),
  5480                                           font, true, NULL);
  5481               width -= it->current_x - it->min_width_start;
  5482               w = list1 (make_int (width));
  5483             }
  5484           else
  5485 #endif
  5486             {
  5487               calc_pixel_width_or_height (&width, it,
  5488                                           XCAR (it->min_width_property),
  5489                                           NULL, true, NULL);
  5490               width -= (it->current_x - it->min_width_start) /
  5491                 FRAME_COLUMN_WIDTH (it->f);
  5492               w = make_int (width);
  5493             }
  5494 
  5495           /* Insert the stretch glyph.  */
  5496           it->object = list3 (Qspace, QCwidth, w);
  5497           produce_stretch_glyph (it);
  5498           if (it->area == TEXT_AREA)
  5499             it->current_x += it->pixel_width;
  5500           it->min_width_property = Qnil;
  5501         }
  5502     }
  5503 
  5504   /* We're at the start of a `min-width' sequence -- record the
  5505      position and the property, so that we can later see if we're at
  5506      the end.  */
  5507   if (CONSP (width_spec))
  5508     {
  5509       if (bufpos == BEGV
  5510           /* Mode line (see above).  */
  5511           || (bufpos == 0
  5512               && !EQ (it->min_width_property,
  5513                       get_display_property (0, Qmin_width, object)))
  5514           /* Buffer.  */
  5515           || (bufpos > BEGV
  5516               && !EQ (width_spec,
  5517                       get_display_property (bufpos - 1, Qmin_width, object))))
  5518         {
  5519           it->min_width_property = width_spec;
  5520           it->min_width_start = it->current_x;
  5521         }
  5522     }
  5523 }
  5524 
  5525 DEFUN ("get-display-property", Fget_display_property,
  5526        Sget_display_property, 2, 4, 0,
  5527        doc: /* Get the value of the `display' property PROP at POSITION.
  5528 If OBJECT, this should be a buffer or string where the property is
  5529 fetched from.  If omitted, OBJECT defaults to the current buffer.
  5530 
  5531 If PROPERTIES, look for value of PROP in PROPERTIES instead of the
  5532 properties at POSITION.  */)
  5533   (Lisp_Object position, Lisp_Object prop, Lisp_Object object,
  5534    Lisp_Object properties)
  5535 {
  5536   if (NILP (properties))
  5537     properties = Fget_text_property (position, Qdisplay, object);
  5538   else
  5539     CHECK_LIST (properties);
  5540 
  5541   return find_display_property (properties, prop);
  5542 }
  5543 
  5544 
  5545 
  5546 /***********************************************************************
  5547                             'display' property
  5548  ***********************************************************************/
  5549 
  5550 /* Set up iterator IT from `display' property at its current position.
  5551    Called from handle_stop.
  5552    We return HANDLED_RETURN if some part of the display property
  5553    overrides the display of the buffer text itself.
  5554    Otherwise we return HANDLED_NORMALLY.  */
  5555 
  5556 static enum prop_handled
  5557 handle_display_prop (struct it *it)
  5558 {
  5559   Lisp_Object propval, object, overlay;
  5560   struct text_pos *position;
  5561   ptrdiff_t bufpos;
  5562   /* Nonzero if some property replaces the display of the text itself.  */
  5563   int display_replaced = 0;
  5564 
  5565   if (STRINGP (it->string))
  5566     {
  5567       object = it->string;
  5568       position = &it->current.string_pos;
  5569       bufpos = CHARPOS (it->current.pos);
  5570     }
  5571   else
  5572     {
  5573       XSETWINDOW (object, it->w);
  5574       position = &it->current.pos;
  5575       bufpos = CHARPOS (*position);
  5576     }
  5577 
  5578   /* Reset those iterator values set from display property values.  */
  5579   it->slice.x = it->slice.y = it->slice.width = it->slice.height = Qnil;
  5580   it->space_width = Qnil;
  5581   it->font_height = Qnil;
  5582   it->voffset = 0;
  5583 
  5584   /* We don't support recursive `display' properties, i.e. string
  5585      values that have a string `display' property, that have a string
  5586      `display' property etc.  */
  5587   if (!it->string_from_display_prop_p)
  5588     it->area = TEXT_AREA;
  5589 
  5590   propval = get_char_property_and_overlay (make_fixnum (position->charpos),
  5591                                            Qdisplay, object, &overlay);
  5592 
  5593   /* Rest of the code must have OBJECT be either a string or a buffer.  */
  5594   if (!STRINGP (it->string))
  5595     object = it->w->contents;
  5596 
  5597   /* Handle min-width ends. */
  5598   if (!NILP (it->min_width_property)
  5599       && NILP (find_display_property (propval, Qmin_width)))
  5600     display_min_width (it, bufpos, object, Qnil);
  5601 
  5602   if (NILP (propval))
  5603     return HANDLED_NORMALLY;
  5604   /* Now OVERLAY is the overlay that gave us this property, or nil
  5605      if it was a text property.  */
  5606 
  5607   display_replaced = handle_display_spec (it, propval, object, overlay,
  5608                                           position, bufpos,
  5609                                           FRAME_WINDOW_P (it->f));
  5610   return display_replaced != 0 ? HANDLED_RETURN : HANDLED_NORMALLY;
  5611 }
  5612 
  5613 /* Subroutine of handle_display_prop.  Returns non-zero if the display
  5614    specification in SPEC is a replacing specification, i.e. it would
  5615    replace the text covered by `display' property with something else,
  5616    such as an image or a display string.  If SPEC includes any kind or
  5617    `(space ...) specification, the value is 2; this is used by
  5618    compute_display_string_pos, which see.
  5619 
  5620    See handle_single_display_spec for documentation of arguments.
  5621    FRAME_WINDOW_P is true if the window being redisplayed is on a
  5622    GUI frame; this argument is used only if IT is NULL, see below.
  5623 
  5624    IT can be NULL, if this is called by the bidi reordering code
  5625    through compute_display_string_pos, which see.  In that case, this
  5626    function only examines SPEC, but does not otherwise "handle" it, in
  5627    the sense that it doesn't set up members of IT from the display
  5628    spec.  */
  5629 static int
  5630 handle_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
  5631                      Lisp_Object overlay, struct text_pos *position,
  5632                      ptrdiff_t bufpos, bool frame_window_p)
  5633 {
  5634   int replacing = 0;
  5635   bool enable_eval = true;
  5636 
  5637   /* Support (disable-eval PROP) which is used by enriched.el.  */
  5638   if (CONSP (spec) && EQ (XCAR (spec), Qdisable_eval))
  5639     {
  5640       enable_eval = false;
  5641       spec = CONSP (XCDR (spec)) ? XCAR (XCDR (spec)) : Qnil;
  5642     }
  5643 
  5644   if (CONSP (spec)
  5645       /* Simple specifications.  */
  5646       && !EQ (XCAR (spec), Qimage)
  5647 #ifdef HAVE_XWIDGETS
  5648       && !EQ (XCAR (spec), Qxwidget)
  5649 #endif
  5650       && !EQ (XCAR (spec), Qspace)
  5651       && !EQ (XCAR (spec), Qwhen)
  5652       && !EQ (XCAR (spec), Qslice)
  5653       && !EQ (XCAR (spec), Qspace_width)
  5654       && !EQ (XCAR (spec), Qheight)
  5655       && !EQ (XCAR (spec), Qraise)
  5656       /* Marginal area specifications.  */
  5657       && !(CONSP (XCAR (spec)) && EQ (XCAR (XCAR (spec)), Qmargin))
  5658       && !EQ (XCAR (spec), Qleft_fringe)
  5659       && !EQ (XCAR (spec), Qright_fringe)
  5660       && !EQ (XCAR (spec), Qmin_width)
  5661       && !NILP (XCAR (spec)))
  5662     {
  5663       for (; CONSP (spec); spec = XCDR (spec))
  5664         {
  5665           int rv = handle_single_display_spec (it, XCAR (spec), object,
  5666                                                overlay, position, bufpos,
  5667                                                replacing, frame_window_p,
  5668                                                enable_eval);
  5669           if (rv != 0)
  5670             {
  5671               replacing = rv;
  5672               /* If some text in a string is replaced, `position' no
  5673                  longer points to the position of `object'.  */
  5674               if (!it || STRINGP (object))
  5675                 break;
  5676             }
  5677         }
  5678     }
  5679   else if (VECTORP (spec))
  5680     {
  5681       ptrdiff_t i;
  5682       for (i = 0; i < ASIZE (spec); ++i)
  5683         {
  5684           int rv = handle_single_display_spec (it, AREF (spec, i), object,
  5685                                                overlay, position, bufpos,
  5686                                                replacing, frame_window_p,
  5687                                                enable_eval);
  5688           if (rv != 0)
  5689             {
  5690               replacing = rv;
  5691               /* If some text in a string is replaced, `position' no
  5692                  longer points to the position of `object'.  */
  5693               if (!it || STRINGP (object))
  5694                 break;
  5695             }
  5696         }
  5697     }
  5698   else
  5699     replacing = handle_single_display_spec (it, spec, object, overlay, position,
  5700                                             bufpos, 0, frame_window_p,
  5701                                             enable_eval);
  5702   return replacing;
  5703 }
  5704 
  5705 /* Value is the position of the end of the `display' property starting
  5706    at START_POS in OBJECT.  */
  5707 
  5708 static struct text_pos
  5709 display_prop_end (struct it *it, Lisp_Object object, struct text_pos start_pos)
  5710 {
  5711   Lisp_Object end;
  5712   struct text_pos end_pos;
  5713 
  5714   end = Fnext_single_char_property_change (make_fixnum (CHARPOS (start_pos)),
  5715                                            Qdisplay, object, Qnil);
  5716   CHARPOS (end_pos) = XFIXNAT (end);
  5717   if (STRINGP (object))
  5718     compute_string_pos (&end_pos, start_pos, it->string);
  5719   else
  5720     BYTEPOS (end_pos) = CHAR_TO_BYTE (XFIXNAT (end));
  5721 
  5722   return end_pos;
  5723 }
  5724 
  5725 
  5726 /* Set up IT from a single `display' property specification SPEC.  OBJECT
  5727    is the object in which the `display' property was found.  *POSITION
  5728    is the position in OBJECT at which the `display' property was found.
  5729    BUFPOS is the buffer position of OBJECT (different from POSITION if
  5730    OBJECT is not a buffer).  DISPLAY_REPLACED non-zero means that we
  5731    previously saw a display specification which already replaced text
  5732    display with something else, for example an image; we ignore such
  5733    properties after the first one has been processed.
  5734 
  5735    OVERLAY is the overlay this `display' property came from,
  5736    or nil if it was a text property.
  5737 
  5738    If SPEC is a `space' or `image' specification, and in some other
  5739    cases too, set *POSITION to the position where the `display'
  5740    property ends.
  5741 
  5742    If IT is NULL, only examine the property specification in SPEC, but
  5743    don't set up IT.  In that case, FRAME_WINDOW_P means SPEC
  5744    is intended to be displayed in a window on a GUI frame.
  5745 
  5746    Enable evaluation of Lisp forms only if ENABLE_EVAL_P is true.
  5747 
  5748    Value is non-zero if something was found which replaces the display
  5749    of buffer or string text.  */
  5750 
  5751 static int
  5752 handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
  5753                             Lisp_Object overlay, struct text_pos *position,
  5754                             ptrdiff_t bufpos, int display_replaced,
  5755                             bool frame_window_p, bool enable_eval_p)
  5756 {
  5757   Lisp_Object form;
  5758   Lisp_Object location, value;
  5759   struct text_pos start_pos = *position;
  5760   void *itdata = NULL;
  5761 
  5762   /* If SPEC is a list of the form `(when FORM . VALUE)', evaluate FORM.
  5763      If the result is non-nil, use VALUE instead of SPEC.  */
  5764   form = Qt;
  5765   if (CONSP (spec) && EQ (XCAR (spec), Qwhen))
  5766     {
  5767       spec = XCDR (spec);
  5768       if (!CONSP (spec))
  5769         return 0;
  5770       form = XCAR (spec);
  5771       spec = XCDR (spec);
  5772     }
  5773 
  5774   if (!NILP (form) && !EQ (form, Qt) && !enable_eval_p)
  5775     form = Qnil;
  5776   if (!NILP (form) && !EQ (form, Qt))
  5777     {
  5778       specpdl_ref count = SPECPDL_INDEX ();
  5779 
  5780       /* Bind `object' to the object having the `display' property, a
  5781          buffer or string.  Bind `position' to the position in the
  5782          object where the property was found, and `buffer-position'
  5783          to the current position in the buffer.  */
  5784 
  5785       if (NILP (object))
  5786         XSETBUFFER (object, current_buffer);
  5787       specbind (Qobject, object);
  5788       specbind (Qposition, make_fixnum (CHARPOS (*position)));
  5789       specbind (Qbuffer_position, make_fixnum (bufpos));
  5790       /* Save and restore the bidi cache, since FORM could be crazy
  5791          enough to re-enter redisplay, e.g., by calling 'message'.  */
  5792       itdata = bidi_shelve_cache ();
  5793       form = safe_eval (form);
  5794       bidi_unshelve_cache (itdata, false);
  5795       form = unbind_to (count, form);
  5796     }
  5797 
  5798   if (NILP (form))
  5799     return 0;
  5800 
  5801   /* Handle `(height HEIGHT)' specifications.  */
  5802   if (CONSP (spec)
  5803       && EQ (XCAR (spec), Qheight)
  5804       && CONSP (XCDR (spec)))
  5805     {
  5806       if (it)
  5807         {
  5808           if (!FRAME_WINDOW_P (it->f))
  5809             return 0;
  5810 
  5811           it->font_height = XCAR (XCDR (spec));
  5812           if (!NILP (it->font_height))
  5813             {
  5814               int new_height = -1;
  5815 
  5816               if (CONSP (it->font_height)
  5817                   && (EQ (XCAR (it->font_height), Qplus)
  5818                       || EQ (XCAR (it->font_height), Qminus))
  5819                   && CONSP (XCDR (it->font_height))
  5820                   && RANGED_FIXNUMP (0, XCAR (XCDR (it->font_height)), INT_MAX))
  5821                 {
  5822                   /* `(+ N)' or `(- N)' where N is an integer.  */
  5823                   int steps = XFIXNUM (XCAR (XCDR (it->font_height)));
  5824                   if (EQ (XCAR (it->font_height), Qplus))
  5825                     steps = - steps;
  5826                   it->face_id = smaller_face (it->f, it->face_id, steps);
  5827                 }
  5828               else if (FUNCTIONP (it->font_height) && enable_eval_p)
  5829                 {
  5830                   /* Call function with current height as argument.
  5831                      Value is the new height.  */
  5832                   struct face *face = FACE_FROM_ID (it->f, it->face_id);
  5833                   Lisp_Object height;
  5834                   itdata = bidi_shelve_cache ();
  5835                   height = safe_call1 (it->font_height,
  5836                                        face->lface[LFACE_HEIGHT_INDEX]);
  5837                   bidi_unshelve_cache (itdata, false);
  5838                   if (NUMBERP (height))
  5839                     new_height = XFLOATINT (height);
  5840                 }
  5841               else if (NUMBERP (it->font_height))
  5842                 {
  5843                   /* Value is a multiple of the canonical char height.  */
  5844                   struct face *f;
  5845 
  5846                   f = FACE_FROM_ID (it->f,
  5847                                     lookup_basic_face (it->w, it->f, DEFAULT_FACE_ID));
  5848                   new_height = (XFLOATINT (it->font_height)
  5849                                 * XFIXNUM (f->lface[LFACE_HEIGHT_INDEX]));
  5850                 }
  5851               else if (enable_eval_p)
  5852                 {
  5853                   /* Evaluate IT->font_height with `height' bound to the
  5854                      current specified height to get the new height.  */
  5855                   specpdl_ref count = SPECPDL_INDEX ();
  5856                   struct face *face = FACE_FROM_ID (it->f, it->face_id);
  5857 
  5858                   specbind (Qheight, face->lface[LFACE_HEIGHT_INDEX]);
  5859                   itdata = bidi_shelve_cache ();
  5860                   value = safe_eval (it->font_height);
  5861                   bidi_unshelve_cache (itdata, false);
  5862                   value = unbind_to (count, value);
  5863 
  5864                   if (NUMBERP (value))
  5865                     new_height = XFLOATINT (value);
  5866                 }
  5867 
  5868               if (new_height > 0)
  5869                 it->face_id = face_with_height (it->f, it->face_id, new_height);
  5870             }
  5871         }
  5872 
  5873       return 0;
  5874     }
  5875 
  5876   /* Handle `(space-width WIDTH)'.  */
  5877   if (CONSP (spec)
  5878       && EQ (XCAR (spec), Qspace_width)
  5879       && CONSP (XCDR (spec)))
  5880     {
  5881       if (it)
  5882         {
  5883           if (!FRAME_WINDOW_P (it->f))
  5884             return 0;
  5885 
  5886           value = XCAR (XCDR (spec));
  5887           if (NUMBERP (value) && XFLOATINT (value) > 0)
  5888             it->space_width = value;
  5889         }
  5890 
  5891       return 0;
  5892     }
  5893 
  5894   /* Handle `(min-width (WIDTH))'.  */
  5895   if (CONSP (spec)
  5896       && EQ (XCAR (spec), Qmin_width)
  5897       && CONSP (XCDR (spec))
  5898       && CONSP (XCAR (XCDR (spec))))
  5899     {
  5900       if (it)
  5901         display_min_width (it, bufpos, object, XCAR (XCDR (spec)));
  5902       return 0;
  5903     }
  5904 
  5905   /* Handle `(slice X Y WIDTH HEIGHT)'.  */
  5906   if (CONSP (spec)
  5907       && EQ (XCAR (spec), Qslice))
  5908     {
  5909       Lisp_Object tem;
  5910 
  5911       if (it)
  5912         {
  5913           if (!FRAME_WINDOW_P (it->f))
  5914             return 0;
  5915 
  5916           if (tem = XCDR (spec), CONSP (tem))
  5917             {
  5918               it->slice.x = XCAR (tem);
  5919               if (tem = XCDR (tem), CONSP (tem))
  5920                 {
  5921                   it->slice.y = XCAR (tem);
  5922                   if (tem = XCDR (tem), CONSP (tem))
  5923                     {
  5924                       it->slice.width = XCAR (tem);
  5925                       if (tem = XCDR (tem), CONSP (tem))
  5926                         it->slice.height = XCAR (tem);
  5927                     }
  5928                 }
  5929             }
  5930         }
  5931 
  5932       return 0;
  5933     }
  5934 
  5935   /* Handle `(raise FACTOR)'.  */
  5936   if (CONSP (spec)
  5937       && EQ (XCAR (spec), Qraise)
  5938       && CONSP (XCDR (spec)))
  5939     {
  5940       if (it)
  5941         {
  5942           if (!FRAME_WINDOW_P (it->f))
  5943             return 0;
  5944 
  5945 #ifdef HAVE_WINDOW_SYSTEM
  5946           value = XCAR (XCDR (spec));
  5947           if (NUMBERP (value))
  5948             {
  5949               struct face *face = FACE_FROM_ID (it->f, it->face_id);
  5950               it->voffset = - (XFLOATINT (value)
  5951                                * (normal_char_height (face->font, -1)));
  5952             }
  5953 #endif /* HAVE_WINDOW_SYSTEM */
  5954         }
  5955 
  5956       return 0;
  5957     }
  5958 
  5959   /* Don't handle the other kinds of display specifications
  5960      inside a string that we got from a `display' property.  */
  5961   if (it && it->string_from_display_prop_p)
  5962     return 0;
  5963 
  5964   /* Characters having this form of property are not displayed, so
  5965      we have to find the end of the property.  */
  5966   if (it)
  5967     {
  5968       start_pos = *position;
  5969       *position = display_prop_end (it, object, start_pos);
  5970       /* If the display property comes from an overlay, don't consider
  5971          any potential stop_charpos values before the end of that
  5972          overlay.  Since display_prop_end will happily find another
  5973          'display' property coming from some other overlay or text
  5974          property on buffer positions before this overlay's end, we
  5975          need to ignore them, or else we risk displaying this
  5976          overlay's display string/image twice.  */
  5977       if (!NILP (overlay))
  5978         {
  5979           ptrdiff_t ovendpos = OVERLAY_END (overlay);
  5980 
  5981           /* Some borderline-sane Lisp might call us with the current
  5982              buffer narrowed so that overlay-end is outside the
  5983              POINT_MIN..POINT_MAX region, which will then cause
  5984              various assertion violations and crashes down the road,
  5985              starting with pop_it when it will attempt to use POSITION
  5986              set below.  Prevent that.  */
  5987           ovendpos = clip_to_bounds (BEGV, ovendpos, ZV);
  5988 
  5989           if (ovendpos > CHARPOS (*position))
  5990             SET_TEXT_POS (*position, ovendpos, CHAR_TO_BYTE (ovendpos));
  5991         }
  5992     }
  5993   value = Qnil;
  5994 
  5995   /* Stop the scan at that end position--we assume that all
  5996      text properties change there.  */
  5997   if (it)
  5998     it->stop_charpos = position->charpos;
  5999 
  6000   /* Handle `(left-fringe BITMAP [FACE])'
  6001      and `(right-fringe BITMAP [FACE])'.  */
  6002   if (CONSP (spec)
  6003       && (EQ (XCAR (spec), Qleft_fringe)
  6004           || EQ (XCAR (spec), Qright_fringe))
  6005       && CONSP (XCDR (spec)))
  6006     {
  6007       if (it)
  6008         {
  6009           if (!FRAME_WINDOW_P (it->f))
  6010             /* If we return here, POSITION has been advanced
  6011                across the text with this property.  */
  6012             {
  6013               /* Synchronize the bidi iterator with POSITION.  This is
  6014                  needed because we are not going to push the iterator
  6015                  on behalf of this display property, so there will be
  6016                  no pop_it call to do this synchronization for us.  */
  6017               if (it->bidi_p)
  6018                 {
  6019                   it->position = *position;
  6020                   iterate_out_of_display_property (it);
  6021                   *position = it->position;
  6022                 }
  6023               return 1;
  6024             }
  6025         }
  6026       else if (!frame_window_p)
  6027         return 1;
  6028 
  6029 #ifdef HAVE_WINDOW_SYSTEM
  6030       value = XCAR (XCDR (spec));
  6031       int fringe_bitmap = SYMBOLP (value) ? lookup_fringe_bitmap (value) : 0;
  6032       if (! fringe_bitmap)
  6033         /* If we return here, POSITION has been advanced
  6034            across the text with this property.  */
  6035         {
  6036           if (it && it->bidi_p)
  6037             {
  6038               it->position = *position;
  6039               iterate_out_of_display_property (it);
  6040               *position = it->position;
  6041             }
  6042           return 1;
  6043         }
  6044 
  6045       if (it)
  6046         {
  6047           int face_id = lookup_basic_face (it->w, it->f, DEFAULT_FACE_ID);
  6048 
  6049           if (CONSP (XCDR (XCDR (spec))))
  6050             {
  6051               Lisp_Object face_name = XCAR (XCDR (XCDR (spec)));
  6052               int face_id2;
  6053               /* Don't allow quitting from lookup_derived_face, for when
  6054                  we are displaying a non-selected window, and the buffer's
  6055                  point was temporarily moved to the window-point.  */
  6056               specpdl_ref count1 = SPECPDL_INDEX ();
  6057               specbind (Qinhibit_quit, Qt);
  6058               face_id2 = lookup_derived_face (it->w, it->f, face_name,
  6059                                               FRINGE_FACE_ID, false);
  6060               unbind_to (count1, Qnil);
  6061               if (face_id2 >= 0)
  6062                 face_id = face_id2;
  6063             }
  6064 
  6065           /* Save current settings of IT so that we can restore them
  6066              when we are finished with the glyph property value.  */
  6067           push_it (it, position);
  6068 
  6069           it->area = TEXT_AREA;
  6070           it->what = IT_IMAGE;
  6071           it->image_id = -1; /* no image */
  6072           it->position = start_pos;
  6073           it->object = NILP (object) ? it->w->contents : object;
  6074           it->method = GET_FROM_IMAGE;
  6075           it->from_overlay = Qnil;
  6076           it->face_id = face_id;
  6077           it->from_disp_prop_p = true;
  6078 
  6079           /* Say that we haven't consumed the characters with
  6080              `display' property yet.  The call to pop_it in
  6081              set_iterator_to_next will clean this up.  */
  6082           *position = start_pos;
  6083 
  6084           if (EQ (XCAR (spec), Qleft_fringe))
  6085             {
  6086               it->left_user_fringe_bitmap = fringe_bitmap;
  6087               it->left_user_fringe_face_id = face_id;
  6088             }
  6089           else
  6090             {
  6091               it->right_user_fringe_bitmap = fringe_bitmap;
  6092               it->right_user_fringe_face_id = face_id;
  6093             }
  6094         }
  6095 #endif /* HAVE_WINDOW_SYSTEM */
  6096       return 1;
  6097     }
  6098 
  6099   /* Prepare to handle `((margin left-margin) ...)',
  6100      `((margin right-margin) ...)' and `((margin nil) ...)'
  6101      prefixes for display specifications.  */
  6102   location = Qunbound;
  6103   if (CONSP (spec) && CONSP (XCAR (spec)))
  6104     {
  6105       Lisp_Object tem;
  6106 
  6107       value = XCDR (spec);
  6108       if (CONSP (value))
  6109         value = XCAR (value);
  6110 
  6111       tem = XCAR (spec);
  6112       if (EQ (XCAR (tem), Qmargin)
  6113           && (tem = XCDR (tem),
  6114               tem = CONSP (tem) ? XCAR (tem) : Qnil,
  6115               (NILP (tem)
  6116                || EQ (tem, Qleft_margin)
  6117                || EQ (tem, Qright_margin))))
  6118         location = tem;
  6119     }
  6120 
  6121   if (BASE_EQ (location, Qunbound))
  6122     {
  6123       location = Qnil;
  6124       value = spec;
  6125     }
  6126 
  6127   /* After this point, VALUE is the property after any
  6128      margin prefix has been stripped.  It must be a string,
  6129      an image specification, or `(space ...)'.
  6130 
  6131      LOCATION specifies where to display: `left-margin',
  6132      `right-margin' or nil.  */
  6133 
  6134   bool valid_p = (STRINGP (value)
  6135 #ifdef HAVE_WINDOW_SYSTEM
  6136                   || ((it ? FRAME_WINDOW_P (it->f) : frame_window_p)
  6137                       && valid_image_p (value))
  6138 #endif /* not HAVE_WINDOW_SYSTEM */
  6139              || (CONSP (value) && EQ (XCAR (value), Qspace))
  6140              || ((it ? FRAME_WINDOW_P (it->f) : frame_window_p)
  6141                  && valid_xwidget_spec_p (value)));
  6142 
  6143   if (valid_p && display_replaced == 0)
  6144     {
  6145       int retval = 1;
  6146 
  6147       if (!it)
  6148         {
  6149           /* Callers need to know whether the display spec is any kind
  6150              of `(space ...)' spec that is about to affect text-area
  6151              display.  */
  6152           if (CONSP (value) && EQ (XCAR (value), Qspace) && NILP (location))
  6153             retval = 2;
  6154           return retval;
  6155         }
  6156 
  6157       /* Save current settings of IT so that we can restore them
  6158          when we are finished with the glyph property value.  */
  6159       push_it (it, position);
  6160       it->from_overlay = overlay;
  6161       it->from_disp_prop_p = true;
  6162 
  6163       if (NILP (location))
  6164         it->area = TEXT_AREA;
  6165       else if (EQ (location, Qleft_margin))
  6166         it->area = LEFT_MARGIN_AREA;
  6167       else
  6168         it->area = RIGHT_MARGIN_AREA;
  6169 
  6170       if (STRINGP (value))
  6171         {
  6172           it->string = value;
  6173           it->multibyte_p = STRING_MULTIBYTE (it->string);
  6174           it->current.overlay_string_index = -1;
  6175           IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
  6176           it->end_charpos = it->string_nchars = SCHARS (it->string);
  6177           it->method = GET_FROM_STRING;
  6178           it->stop_charpos = 0;
  6179           it->prev_stop = 0;
  6180           it->base_level_stop = 0;
  6181           it->string_from_display_prop_p = true;
  6182           it->cmp_it.id = -1;
  6183           /* Say that we haven't consumed the characters with
  6184              `display' property yet.  The call to pop_it in
  6185              set_iterator_to_next will clean this up.  */
  6186           if (BUFFERP (object))
  6187             *position = start_pos;
  6188 
  6189           /* Force paragraph direction to be that of the parent
  6190              object.  If the parent object's paragraph direction is
  6191              not yet determined, default to L2R.  */
  6192           if (it->bidi_p && it->bidi_it.paragraph_dir == R2L)
  6193             it->paragraph_embedding = it->bidi_it.paragraph_dir;
  6194           else
  6195             it->paragraph_embedding = L2R;
  6196 
  6197           /* Set up the bidi iterator for this display string.  */
  6198           if (it->bidi_p)
  6199             {
  6200               it->bidi_it.string.lstring = it->string;
  6201               it->bidi_it.string.s = NULL;
  6202               it->bidi_it.string.schars = it->end_charpos;
  6203               it->bidi_it.string.bufpos = bufpos;
  6204               it->bidi_it.string.from_disp_str = true;
  6205               it->bidi_it.string.unibyte = !it->multibyte_p;
  6206               it->bidi_it.w = it->w;
  6207               bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
  6208             }
  6209         }
  6210       else if (CONSP (value) && EQ (XCAR (value), Qspace))
  6211         {
  6212           it->method = GET_FROM_STRETCH;
  6213           it->object = value;
  6214           *position = it->position = start_pos;
  6215           retval = 1 + (it->area == TEXT_AREA);
  6216         }
  6217       else if (valid_xwidget_spec_p (value))
  6218         {
  6219           it->what = IT_XWIDGET;
  6220           it->method = GET_FROM_XWIDGET;
  6221           it->position = start_pos;
  6222           it->object = NILP (object) ? it->w->contents : object;
  6223           *position = start_pos;
  6224           it->xwidget = lookup_xwidget (value);
  6225         }
  6226 #ifdef HAVE_WINDOW_SYSTEM
  6227       else
  6228         {
  6229           specpdl_ref count = SPECPDL_INDEX ();
  6230 
  6231           it->what = IT_IMAGE;
  6232           /* Don't allow quitting from lookup_image, for when we are
  6233              displaying a non-selected window, and the buffer's point
  6234              was temporarily moved to the window-point.  */
  6235           specbind (Qinhibit_quit, Qt);
  6236           it->image_id = lookup_image (it->f, value, it->face_id);
  6237           unbind_to (count, Qnil);
  6238           it->position = start_pos;
  6239           it->object = NILP (object) ? it->w->contents : object;
  6240           it->method = GET_FROM_IMAGE;
  6241 
  6242           /* Say that we haven't consumed the characters with
  6243              `display' property yet.  The call to pop_it in
  6244              set_iterator_to_next will clean this up.  */
  6245           *position = start_pos;
  6246         }
  6247 #endif /* HAVE_WINDOW_SYSTEM */
  6248 
  6249       return retval;
  6250     }
  6251 
  6252   /* Invalid property or property not supported.  Restore
  6253      POSITION to what it was before.  */
  6254   *position = start_pos;
  6255   return 0;
  6256 }
  6257 
  6258 /* Check if PROP is a display property value whose text should be
  6259    treated as intangible.  OVERLAY is the overlay from which PROP
  6260    came, or nil if it came from a text property.  CHARPOS and BYTEPOS
  6261    specify the buffer position covered by PROP.  */
  6262 
  6263 bool
  6264 display_prop_intangible_p (Lisp_Object prop, Lisp_Object overlay,
  6265                            ptrdiff_t charpos, ptrdiff_t bytepos)
  6266 {
  6267   bool frame_window_p = FRAME_WINDOW_P (XFRAME (selected_frame));
  6268   struct text_pos position;
  6269 
  6270   SET_TEXT_POS (position, charpos, bytepos);
  6271   return (handle_display_spec (NULL, prop, Qnil, overlay,
  6272                                &position, charpos, frame_window_p)
  6273           != 0);
  6274 }
  6275 
  6276 
  6277 /* Return true if PROP is a display sub-property value containing STRING.
  6278 
  6279    Implementation note: this and the following function are really
  6280    special cases of handle_display_spec and
  6281    handle_single_display_spec, and should ideally use the same code.
  6282    Until they do, these two pairs must be consistent and must be
  6283    modified in sync.  */
  6284 
  6285 static bool
  6286 single_display_spec_string_p (Lisp_Object prop, Lisp_Object string)
  6287 {
  6288   if (EQ (string, prop))
  6289     return true;
  6290 
  6291   /* Skip over `when FORM'.  */
  6292   if (CONSP (prop) && EQ (XCAR (prop), Qwhen))
  6293     {
  6294       prop = XCDR (prop);
  6295       if (!CONSP (prop))
  6296         return false;
  6297       /* Actually, the condition following `when' should be eval'ed,
  6298          like handle_single_display_spec does, and we should return
  6299          false if it evaluates to nil.  However, this function is
  6300          called only when the buffer was already displayed and some
  6301          glyph in the glyph matrix was found to come from a display
  6302          string.  Therefore, the condition was already evaluated, and
  6303          the result was non-nil, otherwise the display string wouldn't
  6304          have been displayed and we would have never been called for
  6305          this property.  Thus, we can skip the evaluation and assume
  6306          its result is non-nil.  */
  6307       prop = XCDR (prop);
  6308     }
  6309 
  6310   if (CONSP (prop))
  6311     /* Skip over `margin LOCATION'.  */
  6312     if (EQ (XCAR (prop), Qmargin))
  6313       {
  6314         prop = XCDR (prop);
  6315         if (!CONSP (prop))
  6316           return false;
  6317 
  6318         prop = XCDR (prop);
  6319         if (!CONSP (prop))
  6320           return false;
  6321       }
  6322 
  6323   return EQ (prop, string) || (CONSP (prop) && EQ (XCAR (prop), string));
  6324 }
  6325 
  6326 
  6327 /* Return true if STRING appears in the `display' property PROP.  */
  6328 
  6329 static bool
  6330 display_prop_string_p (Lisp_Object prop, Lisp_Object string)
  6331 {
  6332   if (CONSP (prop)
  6333       && !EQ (XCAR (prop), Qwhen)
  6334       && !(CONSP (XCAR (prop)) && EQ (Qmargin, XCAR (XCAR (prop)))))
  6335     {
  6336       /* A list of sub-properties.  */
  6337       while (CONSP (prop))
  6338         {
  6339           if (single_display_spec_string_p (XCAR (prop), string))
  6340             return true;
  6341           prop = XCDR (prop);
  6342         }
  6343     }
  6344   else if (VECTORP (prop))
  6345     {
  6346       /* A vector of sub-properties.  */
  6347       ptrdiff_t i;
  6348       for (i = 0; i < ASIZE (prop); ++i)
  6349         if (single_display_spec_string_p (AREF (prop, i), string))
  6350           return true;
  6351     }
  6352   else
  6353     return single_display_spec_string_p (prop, string);
  6354 
  6355   return false;
  6356 }
  6357 
  6358 /* Look for STRING in overlays and text properties in the current
  6359    buffer, between character positions FROM and TO (excluding TO).
  6360    BACK_P means look back (in this case, TO is supposed to be
  6361    less than FROM).
  6362    Value is the first character position where STRING was found, or
  6363    zero if it wasn't found before hitting TO.
  6364 
  6365    This function may only use code that doesn't eval because it is
  6366    called asynchronously from note_mouse_highlight.  */
  6367 
  6368 static ptrdiff_t
  6369 string_buffer_position_lim (Lisp_Object string,
  6370                             ptrdiff_t from, ptrdiff_t to, bool back_p)
  6371 {
  6372   Lisp_Object limit, prop, pos;
  6373   bool found = false;
  6374 
  6375   pos = make_fixnum (max (from, BEGV));
  6376 
  6377   if (!back_p)  /* looking forward */
  6378     {
  6379       limit = make_fixnum (min (to, ZV));
  6380       while (!found && !EQ (pos, limit))
  6381         {
  6382           prop = Fget_char_property (pos, Qdisplay, Qnil);
  6383           if (!NILP (prop) && display_prop_string_p (prop, string))
  6384             found = true;
  6385           else
  6386             pos = Fnext_single_char_property_change (pos, Qdisplay, Qnil,
  6387                                                      limit);
  6388         }
  6389     }
  6390   else          /* looking back */
  6391     {
  6392       limit = make_fixnum (max (to, BEGV));
  6393       while (!found && !EQ (pos, limit))
  6394         {
  6395           prop = Fget_char_property (pos, Qdisplay, Qnil);
  6396           if (!NILP (prop) && display_prop_string_p (prop, string))
  6397             found = true;
  6398           else
  6399             pos = Fprevious_single_char_property_change (pos, Qdisplay, Qnil,
  6400                                                          limit);
  6401         }
  6402     }
  6403 
  6404   return found ? XFIXNUM (pos) : 0;
  6405 }
  6406 
  6407 /* Determine which buffer position in current buffer STRING comes from.
  6408    AROUND_CHARPOS is an approximate position where it could come from.
  6409    Value is the buffer position or 0 if it couldn't be determined.
  6410 
  6411    This function is necessary because we don't record buffer positions
  6412    in glyphs generated from strings (to keep struct glyph small).
  6413    This function may only use code that doesn't eval because it is
  6414    called asynchronously from note_mouse_highlight.  */
  6415 
  6416 static ptrdiff_t
  6417 string_buffer_position (Lisp_Object string, ptrdiff_t around_charpos)
  6418 {
  6419   const int MAX_DISTANCE = 1000;
  6420   ptrdiff_t forward_limit = min (around_charpos + MAX_DISTANCE, ZV);
  6421   ptrdiff_t found = string_buffer_position_lim (string, around_charpos,
  6422                                                 forward_limit, false);
  6423 
  6424   if (!found)
  6425     {
  6426       ptrdiff_t backward_limit = max (around_charpos - MAX_DISTANCE, BEGV);
  6427       found = string_buffer_position_lim (string, around_charpos,
  6428                                           backward_limit, true);
  6429     }
  6430   return found;
  6431 }
  6432 
  6433 
  6434 
  6435 /***********************************************************************
  6436                         `composition' property
  6437  ***********************************************************************/
  6438 
  6439 /* Set up iterator IT from `composition' property at its current
  6440    position.  Called from handle_stop.  */
  6441 
  6442 static enum prop_handled
  6443 handle_composition_prop (struct it *it)
  6444 {
  6445   Lisp_Object prop, string;
  6446   ptrdiff_t pos, pos_byte, start, end;
  6447 
  6448   if (STRINGP (it->string))
  6449     {
  6450       unsigned char *s;
  6451 
  6452       pos = IT_STRING_CHARPOS (*it);
  6453       pos_byte = IT_STRING_BYTEPOS (*it);
  6454       string = it->string;
  6455       s = SDATA (string) + pos_byte;
  6456       if (STRING_MULTIBYTE (string))
  6457         it->c = STRING_CHAR (s);
  6458       else
  6459         it->c = *s;
  6460     }
  6461   else
  6462     {
  6463       pos = IT_CHARPOS (*it);
  6464       pos_byte = IT_BYTEPOS (*it);
  6465       string = Qnil;
  6466       it->c = FETCH_CHAR (pos_byte);
  6467     }
  6468 
  6469   /* If there's a valid composition and point is not inside of the
  6470      composition (in the case that the composition is from the current
  6471      buffer), draw a glyph composed from the composition components.  */
  6472   if (find_composition (pos, -1, &start, &end, &prop, string)
  6473       && composition_valid_p (start, end, prop)
  6474       && (STRINGP (it->string) || (PT <= start || PT >= end)))
  6475     {
  6476       if (start < pos)
  6477         /* As we can't handle this situation (perhaps font-lock added
  6478            a new composition), we just return here hoping that next
  6479            redisplay will detect this composition much earlier.  */
  6480         return HANDLED_NORMALLY;
  6481       if (start != pos)
  6482         {
  6483           if (STRINGP (it->string))
  6484             pos_byte = string_char_to_byte (it->string, start);
  6485           else
  6486             pos_byte = CHAR_TO_BYTE (start);
  6487         }
  6488       it->cmp_it.id = get_composition_id (start, pos_byte, end - start,
  6489                                                prop, string);
  6490 
  6491       if (it->cmp_it.id >= 0)
  6492         {
  6493           it->cmp_it.ch = -1;
  6494           it->cmp_it.nchars = COMPOSITION_LENGTH (prop);
  6495           it->cmp_it.nglyphs = -1;
  6496         }
  6497     }
  6498 
  6499   return HANDLED_NORMALLY;
  6500 }
  6501 
  6502 
  6503 
  6504 /***********************************************************************
  6505                            Overlay strings
  6506  ***********************************************************************/
  6507 
  6508 /* The following structure is used to record overlay strings for
  6509    later sorting in load_overlay_strings.  */
  6510 
  6511 struct overlay_entry
  6512 {
  6513   Lisp_Object overlay;
  6514   Lisp_Object string;
  6515   EMACS_INT priority;
  6516   bool after_string_p;
  6517 };
  6518 
  6519 
  6520 /* Set up iterator IT from overlay strings at its current position.
  6521    Called from handle_stop.  */
  6522 
  6523 static enum prop_handled
  6524 handle_overlay_change (struct it *it)
  6525 {
  6526   if (!STRINGP (it->string) && get_overlay_strings (it, 0))
  6527     return HANDLED_RECOMPUTE_PROPS;
  6528   else
  6529     return HANDLED_NORMALLY;
  6530 }
  6531 
  6532 
  6533 /* Set up the next overlay string for delivery by IT, if there is an
  6534    overlay string to deliver.  Called by set_iterator_to_next when the
  6535    end of the current overlay string is reached.  If there are more
  6536    overlay strings to display, IT->string and
  6537    IT->current.overlay_string_index are set appropriately here.
  6538    Otherwise IT->string is set to nil.  */
  6539 
  6540 static void
  6541 next_overlay_string (struct it *it)
  6542 {
  6543   ++it->current.overlay_string_index;
  6544   if (it->current.overlay_string_index == it->n_overlay_strings)
  6545     {
  6546       /* No more overlay strings.  Restore IT's settings to what
  6547          they were before overlay strings were processed, and
  6548          continue to deliver from current_buffer.  */
  6549 
  6550       it->ellipsis_p = it->stack[it->sp - 1].display_ellipsis_p;
  6551       pop_it (it);
  6552       eassert (it->sp > 0
  6553                || (NILP (it->string)
  6554                    && it->method == GET_FROM_BUFFER
  6555                    && it->stop_charpos >= BEGV
  6556                    && it->stop_charpos <= it->end_charpos));
  6557       it->current.overlay_string_index = -1;
  6558       it->n_overlay_strings = 0;
  6559       /* If there's an empty display string on the stack, pop the
  6560          stack, to resync the bidi iterator with IT's position.  Such
  6561          empty strings are pushed onto the stack in
  6562          get_overlay_strings_1.  */
  6563       if (it->sp > 0 && STRINGP (it->string) && !SCHARS (it->string))
  6564         pop_it (it);
  6565 
  6566       /* Since we've exhausted overlay strings at this buffer
  6567          position, set the flag to ignore overlays until we move to
  6568          another position.  (The flag will be reset in
  6569          next_element_from_buffer.)  But don't do that if the overlay
  6570          strings were loaded at position other than the current one,
  6571          which could happen if we called pop_it above, or if the
  6572          overlay strings were loaded by handle_invisible_prop at the
  6573          beginning of invisible text.  */
  6574       if (it->overlay_strings_charpos == IT_CHARPOS (*it))
  6575         it->ignore_overlay_strings_at_pos_p = true;
  6576 
  6577       /* If we're at the end of the buffer, record that we have
  6578          processed the overlay strings there already, so that
  6579          next_element_from_buffer doesn't try it again.  */
  6580       if (NILP (it->string)
  6581           && IT_CHARPOS (*it) >= it->end_charpos
  6582           && it->overlay_strings_charpos >= it->end_charpos)
  6583         it->overlay_strings_at_end_processed_p = true;
  6584       /* Note: we reset overlay_strings_charpos only here, to make
  6585          sure the just-processed overlays were indeed at EOB.
  6586          Otherwise, overlays on text with invisible text property,
  6587          which are processed with IT's position past the invisible
  6588          text, might fool us into thinking the overlays at EOB were
  6589          already processed (linum-mode can cause this, for
  6590          example).  */
  6591       it->overlay_strings_charpos = -1;
  6592     }
  6593   else
  6594     {
  6595       /* There are more overlay strings to process.  If
  6596          IT->current.overlay_string_index has advanced to a position
  6597          where we must load IT->overlay_strings with more strings, do
  6598          it.  We must load at the IT->overlay_strings_charpos where
  6599          IT->n_overlay_strings was originally computed; when invisible
  6600          text is present, this might not be IT_CHARPOS (Bug#7016).  */
  6601       int i = it->current.overlay_string_index % OVERLAY_STRING_CHUNK_SIZE;
  6602 
  6603       if (it->current.overlay_string_index && i == 0)
  6604         load_overlay_strings (it, it->overlay_strings_charpos);
  6605 
  6606       /* Initialize IT to deliver display elements from the overlay
  6607          string.  */
  6608       it->string = it->overlay_strings[i];
  6609       it->multibyte_p = STRING_MULTIBYTE (it->string);
  6610       SET_TEXT_POS (it->current.string_pos, 0, 0);
  6611       it->method = GET_FROM_STRING;
  6612       it->stop_charpos = 0;
  6613       it->end_charpos = SCHARS (it->string);
  6614       if (it->cmp_it.stop_pos >= 0)
  6615         it->cmp_it.stop_pos = 0;
  6616       it->prev_stop = 0;
  6617       it->base_level_stop = 0;
  6618 
  6619       /* Set up the bidi iterator for this overlay string.  */
  6620       if (it->bidi_p)
  6621         {
  6622           it->bidi_it.string.lstring = it->string;
  6623           it->bidi_it.string.s = NULL;
  6624           it->bidi_it.string.schars = SCHARS (it->string);
  6625           it->bidi_it.string.bufpos = it->overlay_strings_charpos;
  6626           it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
  6627           it->bidi_it.string.unibyte = !it->multibyte_p;
  6628           it->bidi_it.w = it->w;
  6629           bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
  6630         }
  6631     }
  6632 
  6633   CHECK_IT (it);
  6634 }
  6635 
  6636 
  6637 /* Compare two overlay_entry structures E1 and E2.  Used as a
  6638    comparison function for qsort in load_overlay_strings.  Overlay
  6639    strings for the same position are sorted so that
  6640 
  6641    1. All after-strings come in front of before-strings, except
  6642    when they come from the same overlay.
  6643 
  6644    2. Within after-strings, strings are sorted so that overlay strings
  6645    from overlays with higher priorities come first.
  6646 
  6647    2. Within before-strings, strings are sorted so that overlay
  6648    strings from overlays with higher priorities come last.
  6649 
  6650    Value is analogous to strcmp.  */
  6651 
  6652 
  6653 static int
  6654 compare_overlay_entries (const void *e1, const void *e2)
  6655 {
  6656   struct overlay_entry const *entry1 = e1;
  6657   struct overlay_entry const *entry2 = e2;
  6658   int result;
  6659 
  6660   if (entry1->after_string_p != entry2->after_string_p)
  6661     {
  6662       /* Let after-strings appear in front of before-strings if
  6663          they come from different overlays.  */
  6664       if (EQ (entry1->overlay, entry2->overlay))
  6665         result = entry1->after_string_p ? 1 : -1;
  6666       else
  6667         result = entry1->after_string_p ? -1 : 1;
  6668     }
  6669   else if (entry1->priority != entry2->priority)
  6670     {
  6671       if (entry1->after_string_p)
  6672         /* After-strings sorted in order of decreasing priority.  */
  6673         result = entry2->priority < entry1->priority ? -1 : 1;
  6674       else
  6675         /* Before-strings sorted in order of increasing priority.  */
  6676         result = entry1->priority < entry2->priority ? -1 : 1;
  6677     }
  6678   else
  6679     result = 0;
  6680 
  6681   return result;
  6682 }
  6683 
  6684 
  6685 /* Load the vector IT->overlay_strings with overlay strings from IT's
  6686    current buffer position, or from CHARPOS if that is > 0.  Set
  6687    IT->n_overlays to the total number of overlay strings found.
  6688 
  6689    Overlay strings are processed OVERLAY_STRING_CHUNK_SIZE strings at
  6690    a time.  On entry into load_overlay_strings,
  6691    IT->current.overlay_string_index gives the number of overlay
  6692    strings that have already been loaded by previous calls to this
  6693    function.
  6694 
  6695    IT->add_overlay_start contains an additional overlay start
  6696    position to consider for taking overlay strings from, if non-zero.
  6697    This position comes into play when the overlay has an `invisible'
  6698    property, and both before and after-strings.  When we've skipped to
  6699    the end of the overlay, because of its `invisible' property, we
  6700    nevertheless want its before-string to appear.
  6701    IT->add_overlay_start will contain the overlay start position
  6702    in this case.
  6703 
  6704    Overlay strings are sorted so that after-string strings come in
  6705    front of before-string strings.  Within before and after-strings,
  6706    strings are sorted by overlay priority.  See also function
  6707    compare_overlay_entries.  */
  6708 
  6709 static void
  6710 load_overlay_strings (struct it *it, ptrdiff_t charpos)
  6711 {
  6712   ptrdiff_t n = 0;
  6713   struct overlay_entry entriesbuf[20];
  6714   ptrdiff_t size = ARRAYELTS (entriesbuf);
  6715   struct overlay_entry *entries = entriesbuf;
  6716   struct itree_node *node;
  6717 
  6718   USE_SAFE_ALLOCA;
  6719 
  6720   if (charpos <= 0)
  6721     charpos = IT_CHARPOS (*it);
  6722 
  6723   /* Append the overlay string STRING of overlay OVERLAY to vector
  6724      `entries' which has size `size' and currently contains `n'
  6725      elements.  AFTER_P means STRING is an after-string of
  6726      OVERLAY.  */
  6727 #define RECORD_OVERLAY_STRING(OVERLAY, STRING, AFTER_P)                 \
  6728   do                                                                    \
  6729     {                                                                   \
  6730       Lisp_Object priority;                                             \
  6731                                                                         \
  6732       if (n == size)                                                    \
  6733         {                                                               \
  6734           struct overlay_entry *old = entries;                          \
  6735           SAFE_NALLOCA (entries, 2, size);                              \
  6736           memcpy (entries, old, size * sizeof *entries);                \
  6737           size *= 2;                                                    \
  6738         }                                                               \
  6739                                                                         \
  6740       entries[n].string = (STRING);                                     \
  6741       entries[n].overlay = (OVERLAY);                                   \
  6742       priority = Foverlay_get ((OVERLAY), Qpriority);                   \
  6743       entries[n].priority = FIXNUMP (priority) ? XFIXNUM (priority) : 0;  \
  6744       entries[n].after_string_p = (AFTER_P);                            \
  6745       ++n;                                                              \
  6746     }                                                                   \
  6747   while (false)
  6748 
  6749 
  6750   /* Process overlays.  */
  6751   ITREE_FOREACH (node, current_buffer->overlays, charpos - 1, charpos + 1, DESCENDING)
  6752     {
  6753       Lisp_Object overlay = node->data;
  6754       eassert (OVERLAYP (overlay));
  6755       ptrdiff_t start = node->begin;
  6756       ptrdiff_t end = node->end;
  6757 
  6758       /* Skip this overlay if it doesn't start or end at IT's current
  6759          position.  */
  6760       if (end != charpos && start != charpos)
  6761         continue;
  6762 
  6763       /* Skip this overlay if it doesn't apply to IT->w.  */
  6764       Lisp_Object window = Foverlay_get (overlay, Qwindow);
  6765       if (WINDOWP (window) && XWINDOW (window) != it->w)
  6766         continue;
  6767 
  6768       /* If the text ``under'' the overlay is invisible, both before-
  6769          and after-strings from this overlay are visible; start and
  6770          end position are indistinguishable.  */
  6771       Lisp_Object invisible = Foverlay_get (overlay, Qinvisible);
  6772       int invis = TEXT_PROP_MEANS_INVISIBLE (invisible);
  6773 
  6774       /* If overlay has a non-empty before-string, record it.  */
  6775       Lisp_Object str;
  6776       if ((start == charpos || (end == charpos && invis != 0))
  6777           && (str = Foverlay_get (overlay, Qbefore_string), STRINGP (str))
  6778           && SCHARS (str))
  6779         RECORD_OVERLAY_STRING (overlay, str, false);
  6780 
  6781       /* If overlay has a non-empty after-string, record it.  */
  6782       if ((end == charpos || (start == charpos && invis != 0))
  6783           && (str = Foverlay_get (overlay, Qafter_string), STRINGP (str))
  6784           && SCHARS (str))
  6785         RECORD_OVERLAY_STRING (overlay, str, true);
  6786     }
  6787 
  6788 #undef RECORD_OVERLAY_STRING
  6789 
  6790   /* Sort entries.  */
  6791   if (n > 1)
  6792     qsort (entries, n, sizeof *entries, compare_overlay_entries);
  6793 
  6794   /* Record number of overlay strings, and where we computed it.  */
  6795   it->n_overlay_strings = n;
  6796   it->overlay_strings_charpos = charpos;
  6797 
  6798   /* IT->current.overlay_string_index is the number of overlay strings
  6799      that have already been consumed by IT.  Copy some of the
  6800      remaining overlay strings to IT->overlay_strings.  */
  6801   ptrdiff_t j = it->current.overlay_string_index;
  6802   for (ptrdiff_t i = 0; i < OVERLAY_STRING_CHUNK_SIZE && j < n; i++, j++)
  6803     {
  6804       it->overlay_strings[i] = entries[j].string;
  6805       it->string_overlays[i] = entries[j].overlay;
  6806     }
  6807 
  6808   CHECK_IT (it);
  6809   SAFE_FREE ();
  6810 }
  6811 
  6812 
  6813 /* Get the first chunk of overlay strings at IT's current buffer
  6814    position, or at CHARPOS if that is > 0.  Value is true if at
  6815    least one overlay string was found.  */
  6816 
  6817 static bool
  6818 get_overlay_strings_1 (struct it *it, ptrdiff_t charpos, bool compute_stop_p)
  6819 {
  6820   /* Get the first OVERLAY_STRING_CHUNK_SIZE overlay strings to
  6821      process.  This fills IT->overlay_strings with strings, and sets
  6822      IT->n_overlay_strings to the total number of strings to process.
  6823      IT->pos.overlay_string_index has to be set temporarily to zero
  6824      because load_overlay_strings needs this; it must be set to -1
  6825      when no overlay strings are found because a zero value would
  6826      indicate a position in the first overlay string.  */
  6827   it->current.overlay_string_index = 0;
  6828   load_overlay_strings (it, charpos);
  6829 
  6830   /* If we found overlay strings, set up IT to deliver display
  6831      elements from the first one.  Otherwise set up IT to deliver
  6832      from current_buffer.  */
  6833   if (it->n_overlay_strings)
  6834     {
  6835       /* Make sure we know settings in current_buffer, so that we can
  6836          restore meaningful values when we're done with the overlay
  6837          strings.  */
  6838       if (compute_stop_p)
  6839         compute_stop_pos (it);
  6840       eassert (it->face_id >= 0);
  6841 
  6842       /* Save IT's settings.  They are restored after all overlay
  6843          strings have been processed.  */
  6844       eassert (!compute_stop_p || it->sp == 0);
  6845 
  6846       /* When called from handle_stop, there might be an empty display
  6847          string loaded.  In that case, don't bother saving it.  But
  6848          don't use this optimization with the bidi iterator, since we
  6849          need the corresponding pop_it call to resync the bidi
  6850          iterator's position with IT's position, after we are done
  6851          with the overlay strings.  (The corresponding call to pop_it
  6852          in case of an empty display string is in
  6853          next_overlay_string.)  */
  6854       if (!(!it->bidi_p
  6855             && STRINGP (it->string) && !SCHARS (it->string)))
  6856         push_it (it, NULL);
  6857 
  6858       /* Set up IT to deliver display elements from the first overlay
  6859          string.  */
  6860       IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
  6861       it->string = it->overlay_strings[0];
  6862       it->from_overlay = Qnil;
  6863       it->stop_charpos = 0;
  6864       eassert (STRINGP (it->string));
  6865       it->end_charpos = SCHARS (it->string);
  6866       it->prev_stop = 0;
  6867       it->base_level_stop = 0;
  6868       it->multibyte_p = STRING_MULTIBYTE (it->string);
  6869       it->method = GET_FROM_STRING;
  6870       it->from_disp_prop_p = 0;
  6871       it->cmp_it.id = -1;
  6872 
  6873       /* Force paragraph direction to be that of the parent
  6874          buffer.  */
  6875       if (it->bidi_p && it->bidi_it.paragraph_dir == R2L)
  6876         it->paragraph_embedding = it->bidi_it.paragraph_dir;
  6877       else
  6878         it->paragraph_embedding = L2R;
  6879 
  6880       /* Set up the bidi iterator for this overlay string.  */
  6881       if (it->bidi_p)
  6882         {
  6883           ptrdiff_t pos = (charpos > 0 ? charpos : IT_CHARPOS (*it));
  6884 
  6885           it->bidi_it.string.lstring = it->string;
  6886           it->bidi_it.string.s = NULL;
  6887           it->bidi_it.string.schars = SCHARS (it->string);
  6888           it->bidi_it.string.bufpos = pos;
  6889           it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
  6890           it->bidi_it.string.unibyte = !it->multibyte_p;
  6891           it->bidi_it.w = it->w;
  6892           bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
  6893         }
  6894       return true;
  6895     }
  6896 
  6897   it->current.overlay_string_index = -1;
  6898   return false;
  6899 }
  6900 
  6901 static bool
  6902 get_overlay_strings (struct it *it, ptrdiff_t charpos)
  6903 {
  6904   it->string = Qnil;
  6905   it->method = GET_FROM_BUFFER;
  6906 
  6907   get_overlay_strings_1 (it, charpos, true);
  6908 
  6909   CHECK_IT (it);
  6910 
  6911   /* Value is true if we found at least one overlay string.  */
  6912   return STRINGP (it->string);
  6913 }
  6914 
  6915 
  6916 
  6917 /***********************************************************************
  6918                       Saving and restoring state
  6919  ***********************************************************************/
  6920 
  6921 /* Save current settings of IT on IT->stack.  Called, for example,
  6922    before setting up IT for an overlay string, to be able to restore
  6923    IT's settings to what they were after the overlay string has been
  6924    processed.  If POSITION is non-NULL, it is the position to save on
  6925    the stack instead of IT->position.  */
  6926 
  6927 static void
  6928 push_it (struct it *it, struct text_pos *position)
  6929 {
  6930   struct iterator_stack_entry *p;
  6931 
  6932   eassert (it->sp < IT_STACK_SIZE);
  6933   p = it->stack + it->sp;
  6934 
  6935   p->stop_charpos = it->stop_charpos;
  6936   p->prev_stop = it->prev_stop;
  6937   p->base_level_stop = it->base_level_stop;
  6938   p->cmp_it = it->cmp_it;
  6939   eassert (it->face_id >= 0);
  6940   p->face_id = it->face_id;
  6941   p->string = it->string;
  6942   p->method = it->method;
  6943   p->from_overlay = it->from_overlay;
  6944   switch (p->method)
  6945     {
  6946     case GET_FROM_IMAGE:
  6947       p->u.image.object = it->object;
  6948       p->u.image.image_id = it->image_id;
  6949       p->u.image.slice = it->slice;
  6950       break;
  6951     case GET_FROM_STRETCH:
  6952       p->u.stretch.object = it->object;
  6953       break;
  6954     case GET_FROM_XWIDGET:
  6955       p->u.xwidget.object = it->object;
  6956       break;
  6957     case GET_FROM_BUFFER:
  6958     case GET_FROM_DISPLAY_VECTOR:
  6959     case GET_FROM_STRING:
  6960     case GET_FROM_C_STRING:
  6961       break;
  6962     default:
  6963       emacs_abort ();
  6964     }
  6965   p->position = position ? *position : it->position;
  6966   p->current = it->current;
  6967   p->end_charpos = it->end_charpos;
  6968   p->string_nchars = it->string_nchars;
  6969   p->area = it->area;
  6970   p->multibyte_p = it->multibyte_p;
  6971   p->avoid_cursor_p = it->avoid_cursor_p;
  6972   p->space_width = it->space_width;
  6973   p->font_height = it->font_height;
  6974   p->voffset = it->voffset;
  6975   p->string_from_display_prop_p = it->string_from_display_prop_p;
  6976   p->string_from_prefix_prop_p = it->string_from_prefix_prop_p;
  6977   p->display_ellipsis_p = false;
  6978   p->line_wrap = it->line_wrap;
  6979   p->bidi_p = it->bidi_p;
  6980   p->paragraph_embedding = it->paragraph_embedding;
  6981   p->from_disp_prop_p = it->from_disp_prop_p;
  6982   ++it->sp;
  6983 
  6984   /* Save the state of the bidi iterator as well. */
  6985   if (it->bidi_p)
  6986     bidi_push_it (&it->bidi_it);
  6987 }
  6988 
  6989 static void
  6990 iterate_out_of_display_property (struct it *it)
  6991 {
  6992   bool buffer_p = !STRINGP (it->string);
  6993   ptrdiff_t eob = (buffer_p ? ZV : it->end_charpos);
  6994   ptrdiff_t bob = (buffer_p ? BEGV : 0);
  6995 
  6996   eassert (eob >= CHARPOS (it->position) && CHARPOS (it->position) >= bob);
  6997 
  6998   /* Maybe initialize paragraph direction.  If we are at the beginning
  6999      of a new paragraph, next_element_from_buffer may not have a
  7000      chance to do that.  */
  7001   if (it->bidi_it.first_elt && it->bidi_it.charpos < eob)
  7002     bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, true);
  7003   /* prev_stop can be zero, so check against BEGV as well.  */
  7004   while (it->bidi_it.charpos >= bob
  7005          && it->prev_stop <= it->bidi_it.charpos
  7006          && it->bidi_it.charpos < CHARPOS (it->position)
  7007          && it->bidi_it.charpos < eob)
  7008     bidi_move_to_visually_next (&it->bidi_it);
  7009   /* Record the stop_pos we just crossed, for when we cross it
  7010      back, maybe.  */
  7011   if (it->bidi_it.charpos > CHARPOS (it->position))
  7012     it->prev_stop = CHARPOS (it->position);
  7013   /* If we ended up not where pop_it put us, resync IT's
  7014      positional members with the bidi iterator. */
  7015   if (it->bidi_it.charpos != CHARPOS (it->position))
  7016     SET_TEXT_POS (it->position, it->bidi_it.charpos, it->bidi_it.bytepos);
  7017   if (buffer_p)
  7018     it->current.pos = it->position;
  7019   else
  7020     it->current.string_pos = it->position;
  7021 }
  7022 
  7023 /* Restore the IT->face_box_p flag, since it could have been
  7024    overwritten by the face of the object that we just finished
  7025    displaying.  Also, set the IT->start_of_box_run_p flag if the
  7026    change in faces requires that.  */
  7027 static void
  7028 restore_face_box_flags (struct it *it, int prev_face_id)
  7029 {
  7030   struct face *face = FACE_FROM_ID_OR_NULL (it->f, it->face_id);
  7031 
  7032   if (face)
  7033     {
  7034       struct face *prev_face = FACE_FROM_ID_OR_NULL (it->f, prev_face_id);
  7035 
  7036       if (!(it->start_of_box_run_p && prev_face && prev_face->box))
  7037         it->start_of_box_run_p = (face->box != FACE_NO_BOX
  7038                                   && (prev_face == NULL
  7039                                       || prev_face->box == FACE_NO_BOX));
  7040       it->face_box_p = face->box != FACE_NO_BOX;
  7041     }
  7042 }
  7043 
  7044 /* Restore IT's settings from IT->stack.  Called, for example, when no
  7045    more overlay strings must be processed, and we return to delivering
  7046    display elements from a buffer, or when the end of a string from a
  7047    `display' property is reached and we return to delivering display
  7048    elements from an overlay string, or from a buffer.  */
  7049 
  7050 static void
  7051 pop_it (struct it *it)
  7052 {
  7053   struct iterator_stack_entry *p;
  7054   bool from_display_prop = it->from_disp_prop_p;
  7055   ptrdiff_t prev_pos = IT_CHARPOS (*it);
  7056   int prev_face_id = it->face_id;
  7057 
  7058   eassert (it->sp > 0);
  7059   --it->sp;
  7060   p = it->stack + it->sp;
  7061   it->stop_charpos = p->stop_charpos;
  7062   it->prev_stop = p->prev_stop;
  7063   it->base_level_stop = p->base_level_stop;
  7064   it->cmp_it = p->cmp_it;
  7065   it->face_id = p->face_id;
  7066   it->current = p->current;
  7067   it->position = p->position;
  7068   it->string = p->string;
  7069   it->from_overlay = p->from_overlay;
  7070   if (NILP (it->string))
  7071     SET_TEXT_POS (it->current.string_pos, -1, -1);
  7072   it->method = p->method;
  7073   switch (it->method)
  7074     {
  7075     case GET_FROM_IMAGE:
  7076       it->image_id = p->u.image.image_id;
  7077       it->object = p->u.image.object;
  7078       it->slice = p->u.image.slice;
  7079       break;
  7080     case GET_FROM_XWIDGET:
  7081       it->object = p->u.xwidget.object;
  7082       break;
  7083     case GET_FROM_STRETCH:
  7084       it->object = p->u.stretch.object;
  7085       break;
  7086     case GET_FROM_BUFFER:
  7087       {
  7088         restore_face_box_flags (it, prev_face_id);
  7089         it->object = it->w->contents;
  7090       }
  7091       break;
  7092     case GET_FROM_STRING:
  7093       {
  7094         restore_face_box_flags (it, prev_face_id);
  7095         it->object = it->string;
  7096       }
  7097       break;
  7098     case GET_FROM_DISPLAY_VECTOR:
  7099       if (it->s)
  7100         it->method = GET_FROM_C_STRING;
  7101       else if (STRINGP (it->string))
  7102         it->method = GET_FROM_STRING;
  7103       else
  7104         {
  7105           it->method = GET_FROM_BUFFER;
  7106           it->object = it->w->contents;
  7107         }
  7108       break;
  7109     case GET_FROM_C_STRING:
  7110       break;
  7111     default:
  7112       emacs_abort ();
  7113     }
  7114   it->end_charpos = p->end_charpos;
  7115   it->string_nchars = p->string_nchars;
  7116   it->area = p->area;
  7117   it->multibyte_p = p->multibyte_p;
  7118   it->avoid_cursor_p = p->avoid_cursor_p;
  7119   it->space_width = p->space_width;
  7120   it->font_height = p->font_height;
  7121   it->voffset = p->voffset;
  7122   it->string_from_display_prop_p = p->string_from_display_prop_p;
  7123   it->string_from_prefix_prop_p = p->string_from_prefix_prop_p;
  7124   it->line_wrap = p->line_wrap;
  7125   it->bidi_p = p->bidi_p;
  7126   it->paragraph_embedding = p->paragraph_embedding;
  7127   it->from_disp_prop_p = p->from_disp_prop_p;
  7128   if (it->bidi_p)
  7129     {
  7130       bidi_pop_it (&it->bidi_it);
  7131       /* Bidi-iterate until we get out of the portion of text, if any,
  7132          covered by a `display' text property or by an overlay with
  7133          `display' property.  (We cannot just jump there, because the
  7134          internal coherency of the bidi iterator state can not be
  7135          preserved across such jumps.)  We also must determine the
  7136          paragraph base direction if the overlay we just processed is
  7137          at the beginning of a new paragraph.  */
  7138       if (from_display_prop
  7139           && (it->method == GET_FROM_BUFFER || it->method == GET_FROM_STRING))
  7140         iterate_out_of_display_property (it);
  7141 
  7142       eassert ((BUFFERP (it->object)
  7143                 && IT_CHARPOS (*it) == it->bidi_it.charpos
  7144                 && IT_BYTEPOS (*it) == it->bidi_it.bytepos)
  7145                || (STRINGP (it->object)
  7146                    && IT_STRING_CHARPOS (*it) == it->bidi_it.charpos
  7147                    && IT_STRING_BYTEPOS (*it) == it->bidi_it.bytepos)
  7148                || (CONSP (it->object) && it->method == GET_FROM_STRETCH)
  7149                /* We could be in the middle of handling a list or a
  7150                   vector of several 'display' properties, in which
  7151                   case we should only verify the above conditions when
  7152                   we pop the iterator stack the last time, because
  7153                   higher stack levels cannot "iterate out of the
  7154                   display property".  */
  7155                || it->sp > 0);
  7156     }
  7157   /* If we move the iterator over text covered by a display property
  7158      to a new buffer position, any info about previously seen overlays
  7159      is no longer valid.  */
  7160   if (from_display_prop && it->sp == 0 && CHARPOS (it->position) != prev_pos)
  7161     it->ignore_overlay_strings_at_pos_p = false;
  7162 }
  7163 
  7164 
  7165 
  7166 /***********************************************************************
  7167                           Moving over lines
  7168  ***********************************************************************/
  7169 
  7170 /* Set IT's current position to the previous line start.  */
  7171 
  7172 static void
  7173 back_to_previous_line_start (struct it *it)
  7174 {
  7175   ptrdiff_t cp = IT_CHARPOS (*it), bp = IT_BYTEPOS (*it);
  7176 
  7177   dec_both (&cp, &bp);
  7178   SET_WITH_NARROWED_BEGV (it, IT_CHARPOS (*it),
  7179                           find_newline_no_quit (cp, bp, -1, &IT_BYTEPOS (*it)),
  7180                           get_small_narrowing_begv (it->w, IT_CHARPOS (*it)));
  7181 }
  7182 
  7183 /* Find in the current buffer the first display or overlay string
  7184    between STARTPOS and ENDPOS that includes embedded newlines.
  7185    Consider only overlays that apply to window W.
  7186    Value is non-zero if such a display/overlay string is found.  */
  7187 static bool
  7188 strings_with_newlines (ptrdiff_t startpos, ptrdiff_t endpos, struct window *w)
  7189 {
  7190   struct itree_node *node;
  7191   /* Process overlays.  */
  7192   ITREE_FOREACH (node, current_buffer->overlays, startpos, endpos, DESCENDING)
  7193     {
  7194       Lisp_Object overlay = node->data;
  7195       eassert (OVERLAYP (overlay));
  7196 
  7197       /* Skip this overlay if it doesn't apply to our window.  */
  7198       Lisp_Object window = Foverlay_get (overlay, Qwindow);
  7199       if (WINDOWP (window) && XWINDOW (window) != w)
  7200         continue;
  7201 
  7202       ptrdiff_t ostart = node->begin;
  7203       ptrdiff_t oend = node->end;
  7204 
  7205       /* Skip overlays that don't overlap the range.  */
  7206       if (!((startpos < oend && ostart < endpos)
  7207             || (ostart == oend
  7208                 && (startpos == oend || (endpos == ZV && oend == endpos)))))
  7209         continue;
  7210 
  7211       Lisp_Object str;
  7212       str = Foverlay_get (overlay, Qbefore_string);
  7213       if (STRINGP (str) && SCHARS (str)
  7214           && memchr (SDATA (str), '\n', SBYTES (str)))
  7215         return true;
  7216       str = Foverlay_get (overlay, Qafter_string);
  7217       if (STRINGP (str) && SCHARS (str)
  7218           && memchr (SDATA (str), '\n', SBYTES (str)))
  7219         return true;
  7220     }
  7221 
  7222   /* Check for 'display' properties whose values include strings.  */
  7223   Lisp_Object cpos = make_fixnum (startpos);
  7224   Lisp_Object limpos = make_fixnum (endpos);
  7225 
  7226   while ((cpos = Fnext_single_property_change (cpos, Qdisplay, Qnil, limpos),
  7227           !(NILP (cpos) || XFIXNAT (cpos) >= endpos)))
  7228     {
  7229       Lisp_Object spec = Fget_char_property (cpos, Qdisplay, Qnil);
  7230       Lisp_Object string = string_from_display_spec (spec);
  7231       if (STRINGP (string)
  7232           && memchr (SDATA (string), '\n', SBYTES (string)))
  7233         return true;
  7234     }
  7235 
  7236   return false;
  7237 }
  7238 
  7239 
  7240 /* Move IT to the next line start.
  7241 
  7242    Value is true if a newline was found.  Set *SKIPPED_P to true if
  7243    we skipped over part of the text (as opposed to moving the iterator
  7244    continuously over the text).  Otherwise, don't change the value
  7245    of *SKIPPED_P.
  7246 
  7247    If BIDI_IT_PREV is non-NULL, store into it the state of the bidi
  7248    iterator on the newline, if it was found.
  7249 
  7250    Newlines may come from buffer text, overlay strings, or strings
  7251    displayed via the `display' property.  That's the reason we can't
  7252    simply use find_newline_no_quit.
  7253 
  7254    Note that this function may not skip over invisible text that is so
  7255    because of text properties and immediately follows a newline.  If
  7256    it would, function reseat_at_next_visible_line_start, when called
  7257    from set_iterator_to_next, would effectively make invisible
  7258    characters following a newline part of the wrong glyph row, which
  7259    leads to wrong cursor motion.  */
  7260 
  7261 static bool
  7262 forward_to_next_line_start (struct it *it, bool *skipped_p,
  7263                             struct bidi_it *bidi_it_prev)
  7264 {
  7265   ptrdiff_t old_selective;
  7266   bool newline_found_p = false;
  7267   int n;
  7268   const int MAX_NEWLINE_DISTANCE = 500;
  7269 
  7270   /* If already on a newline, just consume it to avoid unintended
  7271      skipping over invisible text below.  */
  7272   if (it->what == IT_CHARACTER
  7273       && it->c == '\n'
  7274       && CHARPOS (it->position) == IT_CHARPOS (*it))
  7275     {
  7276       if (it->bidi_p && bidi_it_prev)
  7277         *bidi_it_prev = it->bidi_it;
  7278       set_iterator_to_next (it, false);
  7279       it->c = 0;
  7280       return true;
  7281     }
  7282 
  7283   /* Don't handle selective display in the following.  It's (a)
  7284      unnecessary because it's done by the caller, and (b) leads to an
  7285      infinite recursion because next_element_from_ellipsis indirectly
  7286      calls this function.  */
  7287   old_selective = it->selective;
  7288   it->selective = 0;
  7289 
  7290   /* Scan for a newline within MAX_NEWLINE_DISTANCE display elements
  7291      from buffer text, or till the end of the string if iterating a
  7292      string.  */
  7293   for (n = 0;
  7294        !newline_found_p && n < MAX_NEWLINE_DISTANCE;
  7295        n += !STRINGP (it->string))
  7296     {
  7297       if (!get_next_display_element (it))
  7298         return false;
  7299       newline_found_p = it->what == IT_CHARACTER && it->c == '\n';
  7300       if (newline_found_p && it->bidi_p && bidi_it_prev)
  7301         *bidi_it_prev = it->bidi_it;
  7302       set_iterator_to_next (it, false);
  7303     }
  7304 
  7305   /* If we didn't find a newline near enough, see if we can use a
  7306      short-cut.  */
  7307   if (!newline_found_p)
  7308     {
  7309       ptrdiff_t bytepos, start = IT_CHARPOS (*it);
  7310       ptrdiff_t limit = find_newline_no_quit (start, IT_BYTEPOS (*it),
  7311                                               1, &bytepos);
  7312       eassert (!STRINGP (it->string));
  7313 
  7314       /* it->stop_charpos >= limit means we already know there's no
  7315          stop position up until the newline at LIMIT, so there's no
  7316          need for any further checks.  */
  7317       bool no_strings_with_newlines = it->stop_charpos >= limit;
  7318 
  7319       if (!no_strings_with_newlines)
  7320         {
  7321           if (!(current_buffer->long_line_optimizations_p
  7322                 && it->line_wrap == TRUNCATE))
  7323             {
  7324               /* Quick-and-dirty check: if there isn't any `display'
  7325                  property in sight, and no overlays, we're done.  */
  7326               Lisp_Object pos =
  7327                 Fnext_single_property_change (make_fixnum (start),
  7328                                               Qdisplay, Qnil,
  7329                                               make_fixnum (limit));
  7330               no_strings_with_newlines =
  7331                 (NILP (pos) || XFIXNAT (pos) == limit) /* no 'display' props */
  7332                 && next_overlay_change (start) == ZV;  /* no overlays */
  7333             }
  7334           else
  7335             {
  7336               /* For buffers with very long and truncated lines we try
  7337                  harder, because it's worth our while to spend some
  7338                  time looking into the overlays and 'display' properties
  7339                  if we can then avoid iterating through all of them.  */
  7340               no_strings_with_newlines =
  7341                 !strings_with_newlines (start, limit, it->w);
  7342             }
  7343         }
  7344 
  7345       /* If there's no display or overlay strings with embedded
  7346          newlines until the position of the newline in buffer text, we
  7347          can just use that position.  */
  7348       if (no_strings_with_newlines)
  7349         {
  7350           if (!it->bidi_p || !bidi_it_prev)
  7351             {
  7352               /* The optimal case: just jump there.  */
  7353               IT_CHARPOS (*it) = limit;
  7354               IT_BYTEPOS (*it) = bytepos;
  7355             }
  7356           else
  7357             {
  7358               /* The less optimal case: need to bidi-walk there, but
  7359                  this is still cheaper that the full iteration using
  7360                  get_next_display_element and set_iterator_to_next.  */
  7361               struct bidi_it bprev;
  7362 
  7363               /* Help bidi.c avoid expensive searches for display
  7364                  properties and overlays, by telling it that there are
  7365                  none up to `limit'.  */
  7366               if (it->bidi_it.disp_pos < limit)
  7367                 {
  7368                   it->bidi_it.disp_pos = limit;
  7369                   it->bidi_it.disp_prop = 0;
  7370                 }
  7371               do {
  7372                 bprev = it->bidi_it;
  7373                 bidi_move_to_visually_next (&it->bidi_it);
  7374               } while (it->bidi_it.charpos != limit);
  7375               IT_CHARPOS (*it) = limit;
  7376               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  7377               if (bidi_it_prev)
  7378                 *bidi_it_prev = bprev;
  7379             }
  7380           *skipped_p = newline_found_p = true;
  7381         }
  7382       else
  7383         {
  7384           /* The slow case.  */
  7385           while (!newline_found_p)
  7386             {
  7387               if (!get_next_display_element (it))
  7388                 break;
  7389               newline_found_p = ITERATOR_AT_END_OF_LINE_P (it);
  7390               if (newline_found_p && it->bidi_p && bidi_it_prev)
  7391                 *bidi_it_prev = it->bidi_it;
  7392               set_iterator_to_next (it, false);
  7393             }
  7394         }
  7395     }
  7396 
  7397   it->selective = old_selective;
  7398   return newline_found_p;
  7399 }
  7400 
  7401 
  7402 /* Set IT's current position to the previous visible line start.  Skip
  7403    invisible text that is so either due to text properties or due to
  7404    selective display.  Caution: this does not change IT->current_x and
  7405    IT->hpos.  */
  7406 
  7407 static void
  7408 back_to_previous_visible_line_start (struct it *it)
  7409 {
  7410   while (IT_CHARPOS (*it) > BEGV)
  7411     {
  7412       back_to_previous_line_start (it);
  7413 
  7414       if (IT_CHARPOS (*it) <= BEGV)
  7415         break;
  7416 
  7417       /* If selective > 0, then lines indented more than its value are
  7418          invisible.  */
  7419       if (it->selective > 0
  7420           && indented_beyond_p (IT_CHARPOS (*it), IT_BYTEPOS (*it),
  7421                                 it->selective))
  7422         continue;
  7423 
  7424       /* Check the newline before point for invisibility.  */
  7425       {
  7426         Lisp_Object prop;
  7427         prop = Fget_char_property (make_fixnum (IT_CHARPOS (*it) - 1),
  7428                                    Qinvisible, it->window);
  7429         if (TEXT_PROP_MEANS_INVISIBLE (prop) != 0)
  7430           continue;
  7431       }
  7432 
  7433       if (IT_CHARPOS (*it) <= BEGV)
  7434         break;
  7435 
  7436       {
  7437         struct it it2;
  7438         void *it2data = NULL;
  7439         ptrdiff_t pos;
  7440         ptrdiff_t beg, end;
  7441         Lisp_Object val, overlay;
  7442 
  7443         SAVE_IT (it2, *it, it2data);
  7444 
  7445         /* If newline is part of a composition, continue from start of composition */
  7446         if (find_composition (IT_CHARPOS (*it), -1, &beg, &end, &val, Qnil)
  7447             && beg < IT_CHARPOS (*it))
  7448           goto replaced;
  7449 
  7450         /* If newline is replaced by a display property, find start of overlay
  7451            or interval and continue search from that point.  */
  7452         pos = --IT_CHARPOS (it2);
  7453         --IT_BYTEPOS (it2);
  7454         it2.sp = 0;
  7455         bidi_unshelve_cache (NULL, false);
  7456         it2.string_from_display_prop_p = false;
  7457         it2.from_disp_prop_p = false;
  7458         if (handle_display_prop (&it2) == HANDLED_RETURN
  7459             && !NILP (val = get_char_property_and_overlay
  7460                       (make_fixnum (pos), Qdisplay, Qnil, &overlay))
  7461             && (OVERLAYP (overlay)
  7462                 ? (beg = OVERLAY_START (overlay))
  7463                 : get_property_and_range (pos, Qdisplay, &val, &beg, &end, Qnil)))
  7464           {
  7465             RESTORE_IT (it, it, it2data);
  7466             goto replaced;
  7467           }
  7468 
  7469         /* Newline is not replaced by anything -- so we are done.  */
  7470         RESTORE_IT (it, it, it2data);
  7471         break;
  7472 
  7473       replaced:
  7474         if (beg < BEGV)
  7475           beg = BEGV;
  7476         IT_CHARPOS (*it) = beg;
  7477         IT_BYTEPOS (*it) = buf_charpos_to_bytepos (current_buffer, beg);
  7478       }
  7479     }
  7480 
  7481   it->continuation_lines_width = 0;
  7482 
  7483   eassert (IT_CHARPOS (*it) >= BEGV);
  7484   eassert (it->medium_narrowing_begv > 0 /* long-line optimizations: all bets off */
  7485            || IT_CHARPOS (*it) == BEGV
  7486            || FETCH_BYTE (IT_BYTEPOS (*it) - 1) == '\n');
  7487   CHECK_IT (it);
  7488 }
  7489 
  7490 
  7491 /* Reseat iterator IT at the previous visible line start.  Skip
  7492    invisible text that is so either due to text properties or due to
  7493    selective display.  At the end, update IT's overlay information,
  7494    face information etc.  */
  7495 
  7496 void
  7497 reseat_at_previous_visible_line_start (struct it *it)
  7498 {
  7499   back_to_previous_visible_line_start (it);
  7500   reseat (it, it->current.pos, true);
  7501   CHECK_IT (it);
  7502 }
  7503 
  7504 
  7505 /* Reseat iterator IT on the next visible line start in the current
  7506    buffer.  ON_NEWLINE_P means position IT on the newline
  7507    preceding the line start.  Skip over invisible text that is so
  7508    because of selective display.  Compute faces, overlays etc at the
  7509    new position.  Note that this function does not skip over text that
  7510    is invisible because of text properties.  */
  7511 
  7512 static void
  7513 reseat_at_next_visible_line_start (struct it *it, bool on_newline_p)
  7514 {
  7515   bool skipped_p = false;
  7516   struct bidi_it bidi_it_prev;
  7517   bool newline_found_p
  7518     = forward_to_next_line_start (it, &skipped_p,
  7519                                   on_newline_p ? &bidi_it_prev : NULL);
  7520 
  7521   /* Skip over lines that are invisible because they are indented
  7522      more than the value of IT->selective.  */
  7523   if (it->selective > 0)
  7524     while (IT_CHARPOS (*it) < ZV
  7525            && indented_beyond_p (IT_CHARPOS (*it), IT_BYTEPOS (*it),
  7526                                  it->selective))
  7527       {
  7528         eassert (IT_BYTEPOS (*it) == BEGV
  7529                  || FETCH_BYTE (IT_BYTEPOS (*it) - 1) == '\n');
  7530         newline_found_p =
  7531           forward_to_next_line_start (it, &skipped_p,
  7532                                       on_newline_p ? &bidi_it_prev : NULL);
  7533       }
  7534 
  7535   /* Position on the newline if that's what's requested.  */
  7536   if (on_newline_p && newline_found_p)
  7537     {
  7538       if (STRINGP (it->string))
  7539         {
  7540           if (IT_STRING_CHARPOS (*it) > 0)
  7541             {
  7542               if (!it->bidi_p)
  7543                 {
  7544                   --IT_STRING_CHARPOS (*it);
  7545                   --IT_STRING_BYTEPOS (*it);
  7546                 }
  7547               else
  7548                 {
  7549                   /* We need to restore the bidi iterator to the state
  7550                      it had on the newline, and resync the IT's
  7551                      position with that.  */
  7552                   it->bidi_it = bidi_it_prev;
  7553                   IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
  7554                   IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
  7555                 }
  7556             }
  7557         }
  7558       else if (IT_CHARPOS (*it) > BEGV)
  7559         {
  7560           if (!it->bidi_p)
  7561             {
  7562               --IT_CHARPOS (*it);
  7563               --IT_BYTEPOS (*it);
  7564             }
  7565           else
  7566             {
  7567               /* We need to restore the bidi iterator to the state it
  7568                  had on the newline and resync IT with that.  */
  7569               it->bidi_it = bidi_it_prev;
  7570               IT_CHARPOS (*it) = it->bidi_it.charpos;
  7571               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  7572             }
  7573           reseat (it, it->current.pos, false);
  7574         }
  7575     }
  7576   else if (skipped_p)
  7577     reseat (it, it->current.pos, false);
  7578 
  7579   CHECK_IT (it);
  7580 }
  7581 
  7582 
  7583 
  7584 /***********************************************************************
  7585                    Changing an iterator's position
  7586 ***********************************************************************/
  7587 
  7588 /* Change IT's current position to POS in current_buffer.
  7589    If FORCE_P, always check for text properties at the new position.
  7590    Otherwise, text properties are only looked up if POS >=
  7591    IT->check_charpos of a property.  */
  7592 
  7593 static void
  7594 reseat (struct it *it, struct text_pos pos, bool force_p)
  7595 {
  7596   ptrdiff_t original_pos = IT_CHARPOS (*it);
  7597 
  7598   reseat_1 (it, pos, false);
  7599 
  7600   if (current_buffer->long_line_optimizations_p)
  7601     {
  7602       if (!it->medium_narrowing_begv)
  7603         {
  7604           it->medium_narrowing_begv
  7605             = get_medium_narrowing_begv (it->w, window_point (it->w));
  7606           it->medium_narrowing_zv
  7607             = get_medium_narrowing_zv (it->w, window_point (it->w));
  7608           it->large_narrowing_begv
  7609             = get_large_narrowing_begv (window_point (it->w));
  7610           it->large_narrowing_zv
  7611             = get_large_narrowing_zv (window_point (it->w));
  7612         }
  7613       else if ((pos.charpos < it->medium_narrowing_begv
  7614                 || pos.charpos > it->medium_narrowing_zv)
  7615                 && (!redisplaying_p || it->line_wrap == TRUNCATE))
  7616         {
  7617           it->medium_narrowing_begv
  7618             = get_medium_narrowing_begv (it->w, pos.charpos);
  7619           it->medium_narrowing_zv
  7620             = get_medium_narrowing_zv (it->w, pos.charpos);
  7621           it->large_narrowing_begv
  7622             = get_large_narrowing_begv (window_point (it->w));
  7623           it->large_narrowing_zv
  7624             = get_large_narrowing_zv (window_point (it->w));
  7625         }
  7626     }
  7627 
  7628   /* Determine where to check text properties.  Avoid doing it
  7629      where possible because text property lookup is very expensive.  */
  7630   if (force_p
  7631       || CHARPOS (pos) > it->stop_charpos
  7632       || CHARPOS (pos) < original_pos)
  7633     {
  7634       if (it->bidi_p)
  7635         {
  7636           /* For bidi iteration, we need to prime prev_stop and
  7637              base_level_stop with our best estimations.  */
  7638           /* Implementation note: Of course, POS is not necessarily a
  7639              stop position, so assigning prev_pos to it is a lie; we
  7640              should have called compute_stop_backwards.  However, if
  7641              the current buffer does not include any R2L characters,
  7642              that call would be a waste of cycles, because the
  7643              iterator will never move back, and thus never cross this
  7644              "fake" stop position.  So we delay that backward search
  7645              until the time we really need it, in next_element_from_buffer.  */
  7646           if (CHARPOS (pos) != it->prev_stop)
  7647             it->prev_stop = CHARPOS (pos);
  7648           if (CHARPOS (pos) < it->base_level_stop)
  7649             it->base_level_stop = 0; /* meaning it's unknown */
  7650           handle_stop (it);
  7651         }
  7652       else
  7653         {
  7654           handle_stop (it);
  7655           it->prev_stop = it->base_level_stop = 0;
  7656         }
  7657 
  7658     }
  7659 
  7660   CHECK_IT (it);
  7661 }
  7662 
  7663 
  7664 /* Change IT's buffer position to POS.  SET_STOP_P means set
  7665    IT->stop_pos to POS, also.  */
  7666 
  7667 static void
  7668 reseat_1 (struct it *it, struct text_pos pos, bool set_stop_p)
  7669 {
  7670   /* Don't call this function when scanning a C string.  */
  7671   eassert (it->s == NULL);
  7672 
  7673   /* POS must be a reasonable value.  */
  7674   eassert (CHARPOS (pos) >= BEGV && CHARPOS (pos) <= ZV);
  7675 
  7676   it->current.pos = it->position = pos;
  7677   it->end_charpos = ZV;
  7678   it->dpvec = NULL;
  7679   it->current.dpvec_index = -1;
  7680   it->current.overlay_string_index = -1;
  7681   IT_STRING_CHARPOS (*it) = -1;
  7682   IT_STRING_BYTEPOS (*it) = -1;
  7683   it->string = Qnil;
  7684   it->method = GET_FROM_BUFFER;
  7685   it->object = it->w->contents;
  7686   it->area = TEXT_AREA;
  7687   it->multibyte_p = !NILP (BVAR (current_buffer, enable_multibyte_characters));
  7688   it->sp = 0;
  7689   it->string_from_display_prop_p = false;
  7690   it->string_from_prefix_prop_p = false;
  7691 
  7692   it->from_disp_prop_p = false;
  7693   it->face_before_selective_p = false;
  7694   if (it->bidi_p)
  7695     {
  7696       bidi_init_it (IT_CHARPOS (*it), IT_BYTEPOS (*it), FRAME_WINDOW_P (it->f),
  7697                     &it->bidi_it);
  7698       bidi_unshelve_cache (NULL, false);
  7699       it->bidi_it.paragraph_dir = NEUTRAL_DIR;
  7700       it->bidi_it.string.s = NULL;
  7701       it->bidi_it.string.lstring = Qnil;
  7702       it->bidi_it.string.bufpos = 0;
  7703       it->bidi_it.string.from_disp_str = false;
  7704       it->bidi_it.string.unibyte = false;
  7705       it->bidi_it.w = it->w;
  7706     }
  7707 
  7708   if (set_stop_p)
  7709     {
  7710       it->stop_charpos = CHARPOS (pos);
  7711       it->base_level_stop = CHARPOS (pos);
  7712     }
  7713   /* This make the information stored in it->cmp_it invalidate.  */
  7714   it->cmp_it.id = -1;
  7715   it->min_width_property = Qnil;
  7716 }
  7717 
  7718 
  7719 /* Set up IT for displaying a string, starting at CHARPOS in window W.
  7720    If S is non-null, it is a C string to iterate over.  Otherwise,
  7721    STRING gives a Lisp string to iterate over.
  7722 
  7723    If PRECISION > 0, don't return more then PRECISION number of
  7724    characters from the string.
  7725 
  7726    If FIELD_WIDTH > 0, return padding spaces until FIELD_WIDTH
  7727    characters have been returned.  FIELD_WIDTH < 0 means an infinite
  7728    field width.
  7729 
  7730    MULTIBYTE = 0 means disable processing of multibyte characters,
  7731    MULTIBYTE > 0 means enable it,
  7732    MULTIBYTE < 0 means use IT->multibyte_p.
  7733 
  7734    IT must be initialized via a prior call to init_iterator before
  7735    calling this function.  */
  7736 
  7737 static void
  7738 reseat_to_string (struct it *it, const char *s, Lisp_Object string,
  7739                   ptrdiff_t charpos, ptrdiff_t precision, int field_width,
  7740                   int multibyte)
  7741 {
  7742   /* No text property checks performed by default, but see below.  */
  7743   it->stop_charpos = -1;
  7744 
  7745   /* Set iterator position and end position.  */
  7746   memset (&it->current, 0, sizeof it->current);
  7747   it->current.overlay_string_index = -1;
  7748   it->current.dpvec_index = -1;
  7749   eassert (charpos >= 0);
  7750 
  7751   /* If STRING is specified, use its multibyteness, otherwise use the
  7752      setting of MULTIBYTE, if specified.  */
  7753   if (multibyte >= 0)
  7754     it->multibyte_p = multibyte > 0;
  7755 
  7756   /* Bidirectional reordering of strings is controlled by the default
  7757      value of bidi-display-reordering.  Don't try to reorder while
  7758      loading loadup.el, as the necessary character property tables are
  7759      not yet available.  */
  7760   it->bidi_p =
  7761     !redisplay__inhibit_bidi
  7762     && !NILP (BVAR (&buffer_defaults, bidi_display_reordering));
  7763 
  7764   if (s == NULL)
  7765     {
  7766       eassert (STRINGP (string));
  7767       it->string = string;
  7768       it->s = NULL;
  7769       it->end_charpos = it->string_nchars = SCHARS (string);
  7770       it->method = GET_FROM_STRING;
  7771       it->current.string_pos = string_pos (charpos, string);
  7772 
  7773       if (it->bidi_p)
  7774         {
  7775           it->bidi_it.string.lstring = string;
  7776           it->bidi_it.string.s = NULL;
  7777           it->bidi_it.string.schars = it->end_charpos;
  7778           it->bidi_it.string.bufpos = 0;
  7779           it->bidi_it.string.from_disp_str = false;
  7780           it->bidi_it.string.unibyte = !it->multibyte_p;
  7781           it->bidi_it.w = it->w;
  7782           bidi_init_it (charpos, IT_STRING_BYTEPOS (*it),
  7783                         FRAME_WINDOW_P (it->f), &it->bidi_it);
  7784         }
  7785     }
  7786   else
  7787     {
  7788       it->s = (const unsigned char *) s;
  7789       it->string = Qnil;
  7790 
  7791       /* Note that we use IT->current.pos, not it->current.string_pos,
  7792          for displaying C strings.  */
  7793       IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = -1;
  7794       if (it->multibyte_p)
  7795         {
  7796           it->current.pos = c_string_pos (charpos, s, true);
  7797           it->end_charpos = it->string_nchars = number_of_chars (s, true);
  7798         }
  7799       else
  7800         {
  7801           IT_CHARPOS (*it) = IT_BYTEPOS (*it) = charpos;
  7802           it->end_charpos = it->string_nchars = strlen (s);
  7803         }
  7804 
  7805       if (it->bidi_p)
  7806         {
  7807           it->bidi_it.string.lstring = Qnil;
  7808           it->bidi_it.string.s = (const unsigned char *) s;
  7809           it->bidi_it.string.schars = it->end_charpos;
  7810           it->bidi_it.string.bufpos = 0;
  7811           it->bidi_it.string.from_disp_str = false;
  7812           it->bidi_it.string.unibyte = !it->multibyte_p;
  7813           it->bidi_it.w = it->w;
  7814           bidi_init_it (charpos, IT_BYTEPOS (*it), FRAME_WINDOW_P (it->f),
  7815                         &it->bidi_it);
  7816         }
  7817       it->method = GET_FROM_C_STRING;
  7818     }
  7819 
  7820   /* PRECISION > 0 means don't return more than PRECISION characters
  7821      from the string.  */
  7822   if (precision > 0 && it->end_charpos - charpos > precision)
  7823     {
  7824       it->end_charpos = it->string_nchars = charpos + precision;
  7825       if (it->bidi_p)
  7826         it->bidi_it.string.schars = it->end_charpos;
  7827     }
  7828 
  7829   /* FIELD_WIDTH > 0 means pad with spaces until FIELD_WIDTH
  7830      characters have been returned.  FIELD_WIDTH == 0 means don't pad,
  7831      FIELD_WIDTH < 0 means infinite field width.  This is useful for
  7832      padding with `-' at the end of a mode line.  */
  7833   if (field_width < 0)
  7834     field_width = DISP_INFINITY;
  7835   /* Implementation note: We deliberately don't enlarge
  7836      it->bidi_it.string.schars here to fit it->end_charpos, because
  7837      the bidi iterator cannot produce characters out of thin air.  */
  7838   if (field_width > it->end_charpos - charpos)
  7839     it->end_charpos = charpos + field_width;
  7840 
  7841   /* Use the standard display table for displaying strings.  */
  7842   if (DISP_TABLE_P (Vstandard_display_table))
  7843     it->dp = XCHAR_TABLE (Vstandard_display_table);
  7844 
  7845   it->stop_charpos = charpos;
  7846   it->prev_stop = charpos;
  7847   it->base_level_stop = 0;
  7848   if (it->bidi_p)
  7849     {
  7850       it->bidi_it.first_elt = true;
  7851       it->bidi_it.paragraph_dir = NEUTRAL_DIR;
  7852       it->bidi_it.disp_pos = -1;
  7853     }
  7854   if (s == NULL && it->multibyte_p)
  7855     {
  7856       ptrdiff_t endpos = SCHARS (it->string);
  7857       if (endpos > it->end_charpos)
  7858         endpos = it->end_charpos;
  7859       composition_compute_stop_pos (&it->cmp_it, charpos, -1, endpos,
  7860                                     it->string, true);
  7861     }
  7862   CHECK_IT (it);
  7863 }
  7864 
  7865 
  7866 
  7867 /***********************************************************************
  7868                               Iteration
  7869 ***********************************************************************/
  7870 
  7871 /* Map enum it_method value to corresponding next_element_from_* function.  */
  7872 
  7873 typedef bool (*next_element_function) (struct it *);
  7874 
  7875 static next_element_function const get_next_element[NUM_IT_METHODS] =
  7876 {
  7877   next_element_from_buffer,
  7878   next_element_from_display_vector,
  7879   next_element_from_string,
  7880   next_element_from_c_string,
  7881   next_element_from_image,
  7882   next_element_from_stretch,
  7883   next_element_from_xwidget,
  7884 };
  7885 
  7886 #define GET_NEXT_DISPLAY_ELEMENT(it) (*get_next_element[(it)->method]) (it)
  7887 
  7888 
  7889 /* Return true iff a character at CHARPOS (and BYTEPOS) is composed
  7890    (possibly with the following characters).
  7891 
  7892   Note: we pass -1 as the "resolved bidi level" when the iterator
  7893   doesn't have the bidi_p flag set, because in that case we really
  7894   don't know what is the directionality of the text, so we leave it to
  7895   the shaping engine to figure that out.  */
  7896 
  7897 #define CHAR_COMPOSED_P(IT,CHARPOS,BYTEPOS,END_CHARPOS)                 \
  7898   ((IT)->cmp_it.id >= 0                                                 \
  7899    || ((IT)->cmp_it.stop_pos == (CHARPOS)                               \
  7900        && composition_reseat_it (&(IT)->cmp_it, CHARPOS, BYTEPOS,       \
  7901                                  END_CHARPOS, (IT)->w,                  \
  7902                                  (IT)->bidi_p                           \
  7903                                  ? (IT)->bidi_it.resolved_level         \
  7904                                  : -1,                                  \
  7905                                  FACE_FROM_ID_OR_NULL ((IT)->f,         \
  7906                                                        (IT)->face_id),  \
  7907                                  (IT)->string)))
  7908 
  7909 
  7910 /* Lookup the char-table Vglyphless_char_display for character C (-1
  7911    if we want information for no-font case), and return the display
  7912    method symbol.  By side-effect, update it->what and
  7913    it->glyphless_method.  This function is called from
  7914    get_next_display_element for each character element, and from
  7915    gui_produce_glyphs when no suitable font was found.  */
  7916 
  7917 Lisp_Object
  7918 lookup_glyphless_char_display (int c, struct it *it)
  7919 {
  7920   Lisp_Object glyphless_method = Qnil;
  7921 
  7922   if (CHAR_TABLE_P (Vglyphless_char_display)
  7923       && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display)) >= 1)
  7924     {
  7925       if (c >= 0)
  7926         glyphless_method = CHAR_TABLE_REF (Vglyphless_char_display, c);
  7927       else
  7928         glyphless_method = XCHAR_TABLE (Vglyphless_char_display)->extras[0];
  7929 
  7930       if (CONSP (glyphless_method))
  7931         glyphless_method = FRAME_WINDOW_P (it->f)
  7932           ? XCAR (glyphless_method)
  7933           : XCDR (glyphless_method);
  7934     }
  7935 
  7936  retry:
  7937   if (NILP (glyphless_method))
  7938     {
  7939       if (c >= 0)
  7940         /* The default is to display the character by a proper font.  */
  7941         return Qnil;
  7942       /* The default for the no-font case is to display an empty box.  */
  7943       glyphless_method = Qempty_box;
  7944     }
  7945   if (EQ (glyphless_method, Qzero_width))
  7946     {
  7947       if (c >= 0)
  7948         return glyphless_method;
  7949       /* This method can't be used for the no-font case.  */
  7950       glyphless_method = Qempty_box;
  7951     }
  7952   if (EQ (glyphless_method, Qthin_space))
  7953     it->glyphless_method = GLYPHLESS_DISPLAY_THIN_SPACE;
  7954   else if (EQ (glyphless_method, Qempty_box))
  7955     it->glyphless_method = GLYPHLESS_DISPLAY_EMPTY_BOX;
  7956   else if (EQ (glyphless_method, Qhex_code))
  7957     it->glyphless_method = GLYPHLESS_DISPLAY_HEX_CODE;
  7958   else if (STRINGP (glyphless_method))
  7959     it->glyphless_method = GLYPHLESS_DISPLAY_ACRONYM;
  7960   else
  7961     {
  7962       /* Invalid value.  We use the default method.  */
  7963       glyphless_method = Qnil;
  7964       goto retry;
  7965     }
  7966   it->what = IT_GLYPHLESS;
  7967   return glyphless_method;
  7968 }
  7969 
  7970 /* Merge escape glyph face and cache the result.  */
  7971 
  7972 static struct frame *last_escape_glyph_frame = NULL;
  7973 static int last_escape_glyph_face_id = (1 << FACE_ID_BITS);
  7974 static int last_escape_glyph_merged_face_id = 0;
  7975 
  7976 static int
  7977 merge_escape_glyph_face (struct it *it)
  7978 {
  7979   int face_id;
  7980 
  7981   if (it->f == last_escape_glyph_frame
  7982       && it->face_id == last_escape_glyph_face_id)
  7983     face_id = last_escape_glyph_merged_face_id;
  7984   else
  7985     {
  7986       /* Merge the `escape-glyph' face into the current face.  */
  7987       face_id = merge_faces (it->w, Qescape_glyph, 0, it->face_id);
  7988       last_escape_glyph_frame = it->f;
  7989       last_escape_glyph_face_id = it->face_id;
  7990       last_escape_glyph_merged_face_id = face_id;
  7991     }
  7992   return face_id;
  7993 }
  7994 
  7995 /* Likewise for glyphless glyph face.  */
  7996 
  7997 static struct frame *last_glyphless_glyph_frame = NULL;
  7998 static int last_glyphless_glyph_face_id = (1 << FACE_ID_BITS);
  7999 static int last_glyphless_glyph_merged_face_id = 0;
  8000 
  8001 int
  8002 merge_glyphless_glyph_face (struct it *it)
  8003 {
  8004   int face_id;
  8005 
  8006   if (it->f == last_glyphless_glyph_frame
  8007       && it->face_id == last_glyphless_glyph_face_id)
  8008     face_id = last_glyphless_glyph_merged_face_id;
  8009   else
  8010     {
  8011       /* Merge the `glyphless-char' face into the current face.  */
  8012       face_id = merge_faces (it->w, Qglyphless_char, 0, it->face_id);
  8013       last_glyphless_glyph_frame = it->f;
  8014       last_glyphless_glyph_face_id = it->face_id;
  8015       last_glyphless_glyph_merged_face_id = face_id;
  8016     }
  8017   return face_id;
  8018 }
  8019 
  8020 /* Forget the `escape-glyph' and `glyphless-char' faces.  This should
  8021    be called before redisplaying windows, and when the frame's face
  8022    cache is freed.  */
  8023 void
  8024 forget_escape_and_glyphless_faces (void)
  8025 {
  8026   last_escape_glyph_frame = NULL;
  8027   last_escape_glyph_face_id = (1 << FACE_ID_BITS);
  8028   last_glyphless_glyph_frame = NULL;
  8029   last_glyphless_glyph_face_id = (1 << FACE_ID_BITS);
  8030 }
  8031 
  8032 /* Load IT's display element fields with information about the next
  8033    display element from the current position of IT.  Value is false if
  8034    end of buffer (or C string) is reached.  */
  8035 
  8036 static bool
  8037 get_next_display_element (struct it *it)
  8038 {
  8039   /* True means that we found a display element.  False means that
  8040      we hit the end of what we iterate over.  Performance note: the
  8041      function pointer `method' used here turns out to be faster than
  8042      using a sequence of if-statements.  */
  8043   bool success_p;
  8044 
  8045  get_next:
  8046   success_p = GET_NEXT_DISPLAY_ELEMENT (it);
  8047 
  8048   if (it->what == IT_CHARACTER)
  8049     {
  8050       /* UAX#9, L4: "A character is depicted by a mirrored glyph if
  8051          and only if (a) the resolved directionality of that character
  8052          is R..."  */
  8053       /* FIXME: Do we need an exception for characters from display
  8054          tables?  */
  8055       if (it->bidi_p && it->bidi_it.type == STRONG_R
  8056           && !inhibit_bidi_mirroring)
  8057         it->c = bidi_mirror_char (it->c);
  8058       /* Map via display table or translate control characters.
  8059          IT->c, IT->len etc. have been set to the next character by
  8060          the function call above.  If we have a display table, and it
  8061          contains an entry for IT->c, translate it.  Don't do this if
  8062          IT->c itself comes from a display table, otherwise we could
  8063          end up in an infinite recursion.  (An alternative could be to
  8064          count the recursion depth of this function and signal an
  8065          error when a certain maximum depth is reached.)  Is it worth
  8066          it?  */
  8067       if (success_p && it->dpvec == NULL)
  8068         {
  8069           Lisp_Object dv;
  8070           struct charset *unibyte = CHARSET_FROM_ID (charset_unibyte);
  8071           bool nonascii_space_p = false;
  8072           bool nonascii_hyphen_p = false;
  8073           int c = it->c;        /* This is the character to display.  */
  8074 
  8075           if (! it->multibyte_p && ! ASCII_CHAR_P (c))
  8076             {
  8077               eassert (SINGLE_BYTE_CHAR_P (c));
  8078               if (unibyte_display_via_language_environment)
  8079                 {
  8080                   c = DECODE_CHAR (unibyte, c);
  8081                   if (c < 0)
  8082                     c = BYTE8_TO_CHAR (it->c);
  8083                 }
  8084               else
  8085                 c = BYTE8_TO_CHAR (it->c);
  8086             }
  8087 
  8088           if (it->dp
  8089               && (dv = DISP_CHAR_VECTOR (it->dp, c),
  8090                   VECTORP (dv)))
  8091             {
  8092               struct Lisp_Vector *v = XVECTOR (dv);
  8093 
  8094               /* Return the first character from the display table
  8095                  entry, if not empty.  If empty, don't display the
  8096                  current character.  */
  8097               if (v->header.size)
  8098                 {
  8099                   it->dpvec_char_len = it->len;
  8100                   it->dpvec = v->contents;
  8101                   it->dpend = v->contents + v->header.size;
  8102                   it->current.dpvec_index = 0;
  8103                   it->dpvec_face_id = -1;
  8104                   it->saved_face_id = it->face_id;
  8105                   it->method = GET_FROM_DISPLAY_VECTOR;
  8106                   it->ellipsis_p = false;
  8107                 }
  8108               else
  8109                 {
  8110                   set_iterator_to_next (it, false);
  8111                 }
  8112               goto get_next;
  8113             }
  8114 
  8115           if (! NILP (lookup_glyphless_char_display (c, it)))
  8116             {
  8117               if (it->what == IT_GLYPHLESS)
  8118                 goto done;
  8119               /* Don't display this character.  */
  8120               set_iterator_to_next (it, false);
  8121               goto get_next;
  8122             }
  8123 
  8124           /* If `nobreak-char-display' is non-nil, we display
  8125              non-ASCII spaces and hyphens specially.  */
  8126           if (! ASCII_CHAR_P (c) && ! NILP (Vnobreak_char_display))
  8127             {
  8128               if (blankp (c))
  8129                 nonascii_space_p = true;
  8130               else if (c == SOFT_HYPHEN || c == HYPHEN
  8131                        || c == NON_BREAKING_HYPHEN)
  8132                 nonascii_hyphen_p = true;
  8133             }
  8134 
  8135           /* Translate control characters into `\003' or `^C' form.
  8136              Control characters coming from a display table entry are
  8137              currently not translated because we use IT->dpvec to hold
  8138              the translation.  This could easily be changed but I
  8139              don't believe that it is worth doing.
  8140 
  8141              The characters handled by `nobreak-char-display' must be
  8142              translated too.
  8143 
  8144              Non-printable characters and raw-byte characters are also
  8145              translated to octal or hexadecimal form.  */
  8146           if (((c < ' ' || c == 127) /* ASCII control chars.  */
  8147                ? (it->area != TEXT_AREA
  8148                   /* In mode line, treat \n, \t like other crl chars.  */
  8149                   || (c != '\t'
  8150                       && it->glyph_row
  8151                       && (it->glyph_row->mode_line_p || it->avoid_cursor_p))
  8152                   || (c != '\n' && c != '\t'))
  8153                : (nonascii_space_p
  8154                   || nonascii_hyphen_p
  8155                   || CHAR_BYTE8_P (c)
  8156                   || ! CHAR_PRINTABLE_P (c))))
  8157             {
  8158               /* C is a control character, non-ASCII space/hyphen,
  8159                  raw-byte, or a non-printable character which must be
  8160                  displayed either as '\003' or as `^C' where the '\\'
  8161                  and '^' can be defined in the display table.  Fill
  8162                  IT->ctl_chars with glyphs for what we have to
  8163                  display.  Then, set IT->dpvec to these glyphs.  */
  8164               Lisp_Object gc;
  8165               int ctl_len;
  8166               int face_id;
  8167               int lface_id = 0;
  8168               int escape_glyph;
  8169 
  8170               /* Handle control characters with ^.  */
  8171 
  8172               if (ASCII_CHAR_P (c) && it->ctl_arrow_p)
  8173                 {
  8174                   int g;
  8175 
  8176                   g = '^';           /* default glyph for Control */
  8177                   /* Set IT->ctl_chars[0] to the glyph for `^'.  */
  8178                   if (it->dp
  8179                       && (gc = DISP_CTRL_GLYPH (it->dp), GLYPH_CODE_P (gc)))
  8180                     {
  8181                       g = GLYPH_CODE_CHAR (gc);
  8182                       lface_id = GLYPH_CODE_FACE (gc);
  8183                     }
  8184 
  8185                   face_id = (lface_id
  8186                              ? merge_faces (it->w, Qt, lface_id, it->face_id)
  8187                              : merge_escape_glyph_face (it));
  8188 
  8189                   XSETINT (it->ctl_chars[0], g);
  8190                   XSETINT (it->ctl_chars[1], c ^ 0100);
  8191                   ctl_len = 2;
  8192                   goto display_control;
  8193                 }
  8194 
  8195               /* Handle non-ascii space in the mode where it only gets
  8196                  highlighting.  */
  8197 
  8198               if (nonascii_space_p && EQ (Vnobreak_char_display, Qt))
  8199                 {
  8200                   /* Merge `nobreak-space' into the current face.  */
  8201                   face_id = merge_faces (it->w, Qnobreak_space, 0,
  8202                                          it->face_id);
  8203                   XSETINT (it->ctl_chars[0],
  8204                            nobreak_char_ascii_display ? ' ' : it->c);
  8205                   ctl_len = 1;
  8206                   goto display_control;
  8207                 }
  8208 
  8209               /* Handle non-ascii hyphens in the mode where it only
  8210                  gets highlighting.  */
  8211 
  8212               if (nonascii_hyphen_p && EQ (Vnobreak_char_display, Qt))
  8213                 {
  8214                   /* Merge `nobreak-space' into the current face.  */
  8215                   face_id = merge_faces (it->w, Qnobreak_hyphen, 0,
  8216                                          it->face_id);
  8217                   XSETINT (it->ctl_chars[0],
  8218                            nobreak_char_ascii_display ? '-' : it->c);
  8219                   ctl_len = 1;
  8220                   goto display_control;
  8221                 }
  8222 
  8223               /* Handle sequences that start with the "escape glyph".  */
  8224 
  8225               /* the default escape glyph is \.  */
  8226               escape_glyph = '\\';
  8227 
  8228               if (it->dp
  8229                   && (gc = DISP_ESCAPE_GLYPH (it->dp), GLYPH_CODE_P (gc)))
  8230                 {
  8231                   escape_glyph = GLYPH_CODE_CHAR (gc);
  8232                   lface_id = GLYPH_CODE_FACE (gc);
  8233                 }
  8234 
  8235               face_id = (lface_id
  8236                          ? merge_faces (it->w, Qt, lface_id, it->face_id)
  8237                          : merge_escape_glyph_face (it));
  8238 
  8239               /* Draw non-ASCII space/hyphen with escape glyph: */
  8240 
  8241               if (nonascii_space_p || nonascii_hyphen_p)
  8242                 {
  8243                   XSETINT (it->ctl_chars[0], escape_glyph);
  8244                   XSETINT (it->ctl_chars[1], nonascii_space_p ? ' ' : '-');
  8245                   ctl_len = 2;
  8246                   goto display_control;
  8247                 }
  8248 
  8249               {
  8250                 char str[10];
  8251                 int len, i;
  8252 
  8253                 if (CHAR_BYTE8_P (c))
  8254                   /* Display \200 or \x80 instead of \17777600.  */
  8255                   c = CHAR_TO_BYTE8 (c);
  8256                 const char *format_string = display_raw_bytes_as_hex
  8257                                             ? "x%02x"
  8258                                             : "%03o";
  8259                 len = sprintf (str, format_string, c + 0u);
  8260 
  8261                 XSETINT (it->ctl_chars[0], escape_glyph);
  8262                 for (i = 0; i < len; i++)
  8263                   XSETINT (it->ctl_chars[i + 1], str[i]);
  8264                 ctl_len = len + 1;
  8265               }
  8266 
  8267             display_control:
  8268               /* Set up IT->dpvec and return first character from it.  */
  8269               it->dpvec_char_len = it->len;
  8270               it->dpvec = it->ctl_chars;
  8271               it->dpend = it->dpvec + ctl_len;
  8272               it->current.dpvec_index = 0;
  8273               it->dpvec_face_id = face_id;
  8274               it->saved_face_id = it->face_id;
  8275               it->method = GET_FROM_DISPLAY_VECTOR;
  8276               it->ellipsis_p = false;
  8277               goto get_next;
  8278             }
  8279           it->char_to_display = c;
  8280         }
  8281       else if (success_p)
  8282         {
  8283           it->char_to_display = it->c;
  8284         }
  8285     }
  8286 
  8287 #ifdef HAVE_WINDOW_SYSTEM
  8288   /* Adjust face id for a multibyte character.  There are no multibyte
  8289      character in unibyte text.  */
  8290   if ((it->what == IT_CHARACTER || it->what == IT_COMPOSITION)
  8291       && it->multibyte_p
  8292       && success_p
  8293       && FRAME_WINDOW_P (it->f))
  8294     {
  8295       struct face *face = FACE_FROM_ID (it->f, it->face_id);
  8296 
  8297       if (it->what == IT_COMPOSITION && it->cmp_it.ch >= 0)
  8298         {
  8299           /* Automatic composition with glyph-string.   */
  8300           Lisp_Object gstring = composition_gstring_from_id (it->cmp_it.id);
  8301 
  8302           it->face_id = face_for_font (it->f, LGSTRING_FONT (gstring), face);
  8303         }
  8304       else
  8305         {
  8306           ptrdiff_t pos = (it->s ? -1
  8307                      : STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
  8308                      : IT_CHARPOS (*it));
  8309           int c;
  8310 
  8311           if (it->what == IT_CHARACTER)
  8312             c = it->char_to_display;
  8313           else
  8314             {
  8315               struct composition *cmp = composition_table[it->cmp_it.id];
  8316               int i;
  8317 
  8318               c = ' ';
  8319               for (i = 0; i < cmp->glyph_len; i++)
  8320                 /* TAB in a composition means display glyphs with
  8321                    padding space on the left or right.  */
  8322                 if ((c = COMPOSITION_GLYPH (cmp, i)) != '\t')
  8323                   break;
  8324             }
  8325           it->face_id = FACE_FOR_CHAR (it->f, face, c, pos, it->string);
  8326         }
  8327     }
  8328 #endif  /* HAVE_WINDOW_SYSTEM */
  8329 
  8330  done:
  8331   /* Is this character the last one of a run of characters with
  8332      box?  If yes, set IT->end_of_box_run_p to true.  */
  8333   if (it->face_box_p
  8334       && it->s == NULL)
  8335     {
  8336       if (it->method == GET_FROM_STRING && it->sp)
  8337         {
  8338           int face_id = underlying_face_id (it);
  8339           struct face *face = FACE_FROM_ID_OR_NULL (it->f, face_id);
  8340 
  8341           if (face)
  8342             {
  8343               if (face->box == FACE_NO_BOX)
  8344                 {
  8345                   /* If the box comes from face properties in a
  8346                      display string, check faces in that string.  */
  8347                   int string_face_id = face_after_it_pos (it);
  8348                   if (FACE_FROM_ID (it->f, string_face_id)->box == FACE_NO_BOX)
  8349                     it->end_of_box_run_p = true;
  8350                 }
  8351               /* Otherwise, the box comes from the underlying face.
  8352                  If this is the last string character displayed, check
  8353                  the next buffer location.  */
  8354               else if (((IT_STRING_CHARPOS (*it) >= SCHARS (it->string) - 1)
  8355                         /* For a composition, see if the string ends
  8356                            at the last character included in the
  8357                            composition.  */
  8358                         || (it->what == IT_COMPOSITION
  8359                             && (IT_STRING_CHARPOS (*it) + it->cmp_it.nchars
  8360                                 >= SCHARS (it->string))))
  8361                        /* n_overlay_strings is unreliable unless
  8362                           overlay_string_index is non-negative.  */
  8363                        && ((it->current.overlay_string_index >= 0
  8364                             && (it->current.overlay_string_index
  8365                                 == it->n_overlay_strings - 1))
  8366                            /* A string from display property.  */
  8367                            || it->from_disp_prop_p))
  8368                 {
  8369                   ptrdiff_t ignore;
  8370                   int next_face_id;
  8371                   bool text_from_string = false;
  8372                   /* Normally, the next buffer location is stored in
  8373                      IT->current.pos...  */
  8374                   struct text_pos pos = it->current.pos;
  8375 
  8376                   /* ...but for a string from a display property, the
  8377                      next buffer position is stored in the 'position'
  8378                      member of the iteration stack slot below the
  8379                      current one, see handle_single_display_spec.  By
  8380                      contrast, it->current.pos was not yet updated to
  8381                      point to that buffer position; that will happen
  8382                      in pop_it, after we finish displaying the current
  8383                      string.  Note that we already checked above that
  8384                      it->sp is positive, so subtracting one from it is
  8385                      safe.  */
  8386                   if (it->from_disp_prop_p)
  8387                     {
  8388                       int stackp = it->sp - 1;
  8389 
  8390                       /* Find the stack level with data from buffer.  */
  8391                       while (stackp >= 0
  8392                              && STRINGP ((it->stack + stackp)->string))
  8393                         stackp--;
  8394                       if (stackp < 0)
  8395                         {
  8396                           /* If no stack slot was found for iterating
  8397                              a buffer, we are displaying text from a
  8398                              string, most probably the mode line or
  8399                              the header line, and that string has a
  8400                              display string on some of its
  8401                              characters.  */
  8402                           text_from_string = true;
  8403                           pos = it->stack[it->sp - 1].position;
  8404                         }
  8405                       else
  8406                         pos = (it->stack + stackp)->position;
  8407                     }
  8408                   else
  8409                     INC_TEXT_POS (pos, it->multibyte_p);
  8410 
  8411                   if (text_from_string)
  8412                     {
  8413                       Lisp_Object base_string = it->stack[it->sp - 1].string;
  8414 
  8415                       if (CHARPOS (pos) >= SCHARS (base_string) - 1)
  8416                         it->end_of_box_run_p = true;
  8417                       else
  8418                         {
  8419                           next_face_id
  8420                             = face_at_string_position (it->w, base_string,
  8421                                                        CHARPOS (pos), 0,
  8422                                                        &ignore, face_id,
  8423                                                        false, 0);
  8424                           if (FACE_FROM_ID (it->f, next_face_id)->box
  8425                               == FACE_NO_BOX)
  8426                             it->end_of_box_run_p = true;
  8427                         }
  8428                     }
  8429                   else if (CHARPOS (pos) >= ZV)
  8430                     it->end_of_box_run_p = true;
  8431                   else
  8432                     {
  8433                       next_face_id =
  8434                         face_at_buffer_position (it->w, CHARPOS (pos),
  8435                                                  &ignore,
  8436                                                  CHARPOS (pos)
  8437                                                  + TEXT_PROP_DISTANCE_LIMIT,
  8438                                                  false, -1, 0);
  8439                       if (FACE_FROM_ID (it->f, next_face_id)->box
  8440                           == FACE_NO_BOX)
  8441                         it->end_of_box_run_p = true;
  8442                     }
  8443                 }
  8444             }
  8445         }
  8446       /* next_element_from_display_vector sets this flag according to
  8447          faces of the display vector glyphs, see there.  */
  8448       else if (it->method != GET_FROM_DISPLAY_VECTOR)
  8449         {
  8450           int face_id = face_after_it_pos (it);
  8451           if (face_id != it->face_id
  8452               && FACE_FROM_ID (it->f, face_id)->box == FACE_NO_BOX)
  8453             it->end_of_box_run_p = true;
  8454         }
  8455     }
  8456   /* If we reached the end of the object we've been iterating (e.g., a
  8457      display string or an overlay string), and there's something on
  8458      IT->stack, proceed with what's on the stack.  It doesn't make
  8459      sense to return false if there's unprocessed stuff on the stack,
  8460      because otherwise that stuff will never be displayed.  */
  8461   if (!success_p && it->sp > 0)
  8462     {
  8463       set_iterator_to_next (it, false);
  8464       success_p = get_next_display_element (it);
  8465     }
  8466 
  8467   /* Value is false if end of buffer or string reached.  */
  8468   return success_p;
  8469 }
  8470 
  8471 
  8472 /* Move IT to the next display element.
  8473 
  8474    RESEAT_P means if called on a newline in buffer text,
  8475    skip to the next visible line start.
  8476 
  8477    Functions get_next_display_element and set_iterator_to_next are
  8478    separate because I find this arrangement easier to handle than a
  8479    get_next_display_element function that also increments IT's
  8480    position.  The way it is we can first look at an iterator's current
  8481    display element, decide whether it fits on a line, and if it does,
  8482    increment the iterator position.  The other way around we probably
  8483    would either need a flag indicating whether the iterator has to be
  8484    incremented the next time, or we would have to implement a
  8485    decrement position function which would not be easy to write.  */
  8486 
  8487 void
  8488 set_iterator_to_next (struct it *it, bool reseat_p)
  8489 {
  8490 
  8491   if (max_redisplay_ticks > 0)
  8492     update_redisplay_ticks (1, it->w);
  8493 
  8494   switch (it->method)
  8495     {
  8496     case GET_FROM_BUFFER:
  8497       /* The current display element of IT is a character from
  8498          current_buffer.  Advance in the buffer, and maybe skip over
  8499          invisible lines that are so because of selective display.  */
  8500       if (ITERATOR_AT_END_OF_LINE_P (it) && reseat_p)
  8501         reseat_at_next_visible_line_start (it, false);
  8502       else if (it->cmp_it.id >= 0)
  8503         {
  8504           /* We are currently getting glyphs from a composition.  */
  8505           if (! it->bidi_p)
  8506             {
  8507               IT_CHARPOS (*it) += it->cmp_it.nchars;
  8508               IT_BYTEPOS (*it) += it->cmp_it.nbytes;
  8509             }
  8510           else
  8511             {
  8512               int i;
  8513 
  8514               /* Update IT's char/byte positions to point to the first
  8515                  character of the next grapheme cluster, or to the
  8516                  character visually after the current composition.  */
  8517               for (i = 0; i < it->cmp_it.nchars; i++)
  8518                 bidi_move_to_visually_next (&it->bidi_it);
  8519               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  8520               IT_CHARPOS (*it) = it->bidi_it.charpos;
  8521             }
  8522 
  8523           if ((! it->bidi_p || ! it->cmp_it.reversed_p)
  8524               && it->cmp_it.to < it->cmp_it.nglyphs)
  8525             {
  8526               /* Composition created while scanning forward.  Proceed
  8527                  to the next grapheme cluster.  */
  8528               it->cmp_it.from = it->cmp_it.to;
  8529             }
  8530           else if ((it->bidi_p && it->cmp_it.reversed_p)
  8531                    && it->cmp_it.from > 0)
  8532             {
  8533               /* Composition created while scanning backward.  Proceed
  8534                  to the previous grapheme cluster.  */
  8535               it->cmp_it.to = it->cmp_it.from;
  8536             }
  8537           else
  8538             {
  8539               /* No more grapheme clusters in this composition.
  8540                  Find the next stop position.  */
  8541               ptrdiff_t stop = it->end_charpos;
  8542 
  8543               if (it->bidi_it.scan_dir < 0)
  8544                 /* Now we are scanning backward and don't know
  8545                    where to stop.  */
  8546                 stop = -1;
  8547               composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
  8548                                             IT_BYTEPOS (*it), stop, Qnil, true);
  8549             }
  8550         }
  8551       else
  8552         {
  8553           eassert (it->len != 0);
  8554 
  8555           if (!it->bidi_p)
  8556             {
  8557               IT_BYTEPOS (*it) += it->len;
  8558               IT_CHARPOS (*it) += 1;
  8559             }
  8560           else
  8561             {
  8562               int prev_scan_dir = it->bidi_it.scan_dir;
  8563               /* If this is a new paragraph, determine its base
  8564                  direction (a.k.a. its base embedding level).  */
  8565               if (it->bidi_it.new_paragraph)
  8566                 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it,
  8567                                      false);
  8568               bidi_move_to_visually_next (&it->bidi_it);
  8569               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  8570               IT_CHARPOS (*it) = it->bidi_it.charpos;
  8571               if (prev_scan_dir != it->bidi_it.scan_dir)
  8572                 {
  8573                   /* As the scan direction was changed, we must
  8574                      re-compute the stop position for composition.  */
  8575                   ptrdiff_t stop = it->end_charpos;
  8576                   if (it->bidi_it.scan_dir < 0)
  8577                     stop = -1;
  8578                   composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
  8579                                                 IT_BYTEPOS (*it), stop, Qnil,
  8580                                                 true);
  8581                 }
  8582             }
  8583           eassert (IT_BYTEPOS (*it) == CHAR_TO_BYTE (IT_CHARPOS (*it)));
  8584         }
  8585       break;
  8586 
  8587     case GET_FROM_C_STRING:
  8588       /* Current display element of IT is from a C string.  */
  8589       if (!it->bidi_p
  8590           /* If the string position is beyond string's end, it means
  8591              next_element_from_c_string is padding the string with
  8592              blanks, in which case we bypass the bidi iterator,
  8593              because it cannot deal with such virtual characters.  */
  8594           || IT_CHARPOS (*it) >= it->bidi_it.string.schars)
  8595         {
  8596           IT_BYTEPOS (*it) += it->len;
  8597           IT_CHARPOS (*it) += 1;
  8598         }
  8599       else
  8600         {
  8601           bidi_move_to_visually_next (&it->bidi_it);
  8602           IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  8603           IT_CHARPOS (*it) = it->bidi_it.charpos;
  8604         }
  8605       break;
  8606 
  8607     case GET_FROM_DISPLAY_VECTOR:
  8608       /* Current display element of IT is from a display table entry.
  8609          Advance in the display table definition.  Reset it to null if
  8610          end reached, and continue with characters from buffers/
  8611          strings.  */
  8612       ++it->current.dpvec_index;
  8613 
  8614       /* Restore face of the iterator to what they were before the
  8615          display vector entry (these entries may contain faces).  */
  8616       it->face_id = it->saved_face_id;
  8617 
  8618       if (it->dpvec + it->current.dpvec_index >= it->dpend)
  8619         {
  8620           bool recheck_faces = it->ellipsis_p;
  8621 
  8622           if (it->s)
  8623             it->method = GET_FROM_C_STRING;
  8624           else if (STRINGP (it->string))
  8625             it->method = GET_FROM_STRING;
  8626           else
  8627             {
  8628               it->method = GET_FROM_BUFFER;
  8629               it->object = it->w->contents;
  8630             }
  8631 
  8632           it->dpvec = NULL;
  8633           it->current.dpvec_index = -1;
  8634 
  8635           /* Skip over characters which were displayed via IT->dpvec.  */
  8636           if (it->dpvec_char_len < 0)
  8637             reseat_at_next_visible_line_start (it, true);
  8638           else if (it->dpvec_char_len > 0)
  8639             {
  8640               it->len = it->dpvec_char_len;
  8641               set_iterator_to_next (it, reseat_p);
  8642             }
  8643 
  8644           /* Maybe recheck faces after display vector.  */
  8645           if (recheck_faces)
  8646             {
  8647               if (it->method == GET_FROM_STRING)
  8648                 it->stop_charpos = IT_STRING_CHARPOS (*it);
  8649               else
  8650                 it->stop_charpos = IT_CHARPOS (*it);
  8651             }
  8652         }
  8653       break;
  8654 
  8655     case GET_FROM_STRING:
  8656       /* Current display element is a character from a Lisp string.  */
  8657       eassert (it->s == NULL && STRINGP (it->string));
  8658       /* Don't advance past string end.  These conditions are true
  8659          when set_iterator_to_next is called at the end of
  8660          get_next_display_element, in which case the Lisp string is
  8661          already exhausted, and all we want is pop the iterator
  8662          stack.  */
  8663       if (it->current.overlay_string_index >= 0)
  8664         {
  8665           /* This is an overlay string, so there's no padding with
  8666              spaces, and the number of characters in the string is
  8667              where the string ends.  */
  8668           if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
  8669             goto consider_string_end;
  8670         }
  8671       else
  8672         {
  8673           /* Not an overlay string.  There could be padding, so test
  8674              against it->end_charpos.  */
  8675           if (IT_STRING_CHARPOS (*it) >= it->end_charpos)
  8676             goto consider_string_end;
  8677         }
  8678       if (it->cmp_it.id >= 0)
  8679         {
  8680           /* We are delivering display elements from a composition.
  8681              Update the string position past the grapheme cluster
  8682              we've just processed.  */
  8683           if (! it->bidi_p)
  8684             {
  8685               IT_STRING_CHARPOS (*it) += it->cmp_it.nchars;
  8686               IT_STRING_BYTEPOS (*it) += it->cmp_it.nbytes;
  8687             }
  8688           else
  8689             {
  8690               int i;
  8691 
  8692               for (i = 0; i < it->cmp_it.nchars; i++)
  8693                 bidi_move_to_visually_next (&it->bidi_it);
  8694               IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
  8695               IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
  8696             }
  8697 
  8698           /* Did we exhaust all the grapheme clusters of this
  8699              composition?  */
  8700           if ((! it->bidi_p || ! it->cmp_it.reversed_p)
  8701               && (it->cmp_it.to < it->cmp_it.nglyphs))
  8702             {
  8703               /* Not all the grapheme clusters were processed yet;
  8704                  advance to the next cluster.  */
  8705               it->cmp_it.from = it->cmp_it.to;
  8706             }
  8707           else if ((it->bidi_p && it->cmp_it.reversed_p)
  8708                    && it->cmp_it.from > 0)
  8709             {
  8710               /* Likewise: advance to the next cluster, but going in
  8711                  the reverse direction.  */
  8712               it->cmp_it.to = it->cmp_it.from;
  8713             }
  8714           else
  8715             {
  8716               /* This composition was fully processed; find the next
  8717                  candidate place for checking for composed
  8718                  characters.  */
  8719               /* Always limit string searches to the string length;
  8720                  any padding spaces are not part of the string, and
  8721                  there cannot be any compositions in that padding.  */
  8722               ptrdiff_t stop = SCHARS (it->string);
  8723 
  8724               if (it->bidi_p && it->bidi_it.scan_dir < 0)
  8725                 stop = -1;
  8726               else if (it->end_charpos < stop)
  8727                 {
  8728                   /* Cf. PRECISION in reseat_to_string: we might be
  8729                      limited in how many of the string characters we
  8730                      need to deliver.  */
  8731                   stop = it->end_charpos;
  8732                 }
  8733               composition_compute_stop_pos (&it->cmp_it,
  8734                                             IT_STRING_CHARPOS (*it),
  8735                                             IT_STRING_BYTEPOS (*it), stop,
  8736                                             it->string, true);
  8737             }
  8738         }
  8739       else
  8740         {
  8741           if (!it->bidi_p
  8742               /* If the string position is beyond string's end, it
  8743                  means next_element_from_string is padding the string
  8744                  with blanks, in which case we bypass the bidi
  8745                  iterator, because it cannot deal with such virtual
  8746                  characters.  */
  8747               || IT_STRING_CHARPOS (*it) >= it->bidi_it.string.schars)
  8748             {
  8749               IT_STRING_BYTEPOS (*it) += it->len;
  8750               IT_STRING_CHARPOS (*it) += 1;
  8751             }
  8752           else
  8753             {
  8754               int prev_scan_dir = it->bidi_it.scan_dir;
  8755 
  8756               bidi_move_to_visually_next (&it->bidi_it);
  8757               IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
  8758               IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
  8759               /* If the scan direction changes, we may need to update
  8760                  the place where to check for composed characters.  */
  8761               if (prev_scan_dir != it->bidi_it.scan_dir)
  8762                 {
  8763                   ptrdiff_t stop = SCHARS (it->string);
  8764 
  8765                   if (it->bidi_it.scan_dir < 0)
  8766                     stop = -1;
  8767                   else if (it->end_charpos < stop)
  8768                     stop = it->end_charpos;
  8769 
  8770                   composition_compute_stop_pos (&it->cmp_it,
  8771                                                 IT_STRING_CHARPOS (*it),
  8772                                                 IT_STRING_BYTEPOS (*it), stop,
  8773                                                 it->string, true);
  8774                 }
  8775             }
  8776         }
  8777 
  8778     consider_string_end:
  8779 
  8780       if (it->current.overlay_string_index >= 0)
  8781         {
  8782           /* IT->string is an overlay string.  Advance to the
  8783              next, if there is one.  */
  8784           if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
  8785             {
  8786               it->ellipsis_p = false;
  8787               next_overlay_string (it);
  8788               if (it->ellipsis_p)
  8789                 setup_for_ellipsis (it, 0);
  8790             }
  8791         }
  8792       else
  8793         {
  8794           /* IT->string is not an overlay string.  If we reached
  8795              its end, and there is something on IT->stack, proceed
  8796              with what is on the stack.  This can be either another
  8797              string, this time an overlay string, or a buffer.  */
  8798           if (IT_STRING_CHARPOS (*it) == SCHARS (it->string)
  8799               && it->sp > 0)
  8800             {
  8801               pop_it (it);
  8802               if (it->method == GET_FROM_STRING)
  8803                 goto consider_string_end;
  8804             }
  8805         }
  8806       break;
  8807 
  8808     case GET_FROM_IMAGE:
  8809     case GET_FROM_STRETCH:
  8810     case GET_FROM_XWIDGET:
  8811 
  8812       /* The position etc with which we have to proceed are on
  8813          the stack.  The position may be at the end of a string,
  8814          if the `display' property takes up the whole string.  */
  8815       eassert (it->sp > 0);
  8816       pop_it (it);
  8817       if (it->method == GET_FROM_STRING)
  8818         goto consider_string_end;
  8819       break;
  8820 
  8821     default:
  8822       /* There are no other methods defined, so this should be a bug.  */
  8823       emacs_abort ();
  8824     }
  8825 
  8826   eassert (it->method != GET_FROM_STRING
  8827            || (STRINGP (it->string)
  8828                && IT_STRING_CHARPOS (*it) >= 0));
  8829 }
  8830 
  8831 /* Load IT's display element fields with information about the next
  8832    display element which comes from a display table entry or from the
  8833    result of translating a control character to one of the forms `^C'
  8834    or `\003'.
  8835 
  8836    IT->dpvec holds the glyphs to return as characters.
  8837    IT->saved_face_id holds the face id before the display vector--it
  8838    is restored into IT->face_id in set_iterator_to_next.  */
  8839 
  8840 static bool
  8841 next_element_from_display_vector (struct it *it)
  8842 {
  8843   Lisp_Object gc;
  8844   int prev_face_id = it->face_id;
  8845   int next_face_id;
  8846 
  8847   /* Precondition.  */
  8848   eassert (it->dpvec && it->current.dpvec_index >= 0);
  8849 
  8850   it->face_id = it->saved_face_id;
  8851 
  8852   /* KFS: This code used to check ip->dpvec[0] instead of the current element.
  8853      That seemed totally bogus - so I changed it...  */
  8854   if (it->dpend - it->dpvec > 0 /* empty dpvec[] is invalid */
  8855       && (gc = it->dpvec[it->current.dpvec_index], GLYPH_CODE_P (gc)))
  8856     {
  8857       struct face *this_face, *prev_face, *next_face;
  8858 
  8859       it->c = GLYPH_CODE_CHAR (gc);
  8860       it->len = CHAR_BYTES (it->c);
  8861 
  8862       /* The entry may contain a face id to use.  Such a face id is
  8863          the id of a Lisp face, not a realized face.  A face id of
  8864          zero means no face is specified.  */
  8865       if (it->dpvec_face_id >= 0)
  8866         it->face_id = it->dpvec_face_id;
  8867       else
  8868         {
  8869           int lface_id = GLYPH_CODE_FACE (gc);
  8870           if (lface_id > 0)
  8871             it->face_id = merge_faces (it->w, Qt, lface_id,
  8872                                        it->saved_face_id);
  8873         }
  8874 
  8875       /* Glyphs in the display vector could have the box face, so we
  8876          need to set the related flags in the iterator, as
  8877          appropriate.  */
  8878       this_face = FACE_FROM_ID_OR_NULL (it->f, it->face_id);
  8879       prev_face = FACE_FROM_ID_OR_NULL (it->f, prev_face_id);
  8880 
  8881       /* Is this character the first character of a box-face run?  */
  8882       it->start_of_box_run_p = (this_face && this_face->box != FACE_NO_BOX
  8883                                 && (!prev_face
  8884                                     || prev_face->box == FACE_NO_BOX));
  8885 
  8886       /* For the last character of the box-face run, we need to look
  8887          either at the next glyph from the display vector, or at the
  8888          face we saw before the display vector.  */
  8889       next_face_id = it->saved_face_id;
  8890       if (it->current.dpvec_index < it->dpend - it->dpvec - 1)
  8891         {
  8892           if (it->dpvec_face_id >= 0)
  8893             next_face_id = it->dpvec_face_id;
  8894           else
  8895             {
  8896               Lisp_Object gc = it->dpvec[it->current.dpvec_index + 1];
  8897               int lface_id = GLYPH_CODE_P (gc) ? GLYPH_CODE_FACE (gc) : 0;
  8898 
  8899               if (lface_id > 0)
  8900                 next_face_id = merge_faces (it->w, Qt, lface_id,
  8901                                             it->saved_face_id);
  8902             }
  8903         }
  8904       next_face = FACE_FROM_ID_OR_NULL (it->f, next_face_id);
  8905       if (this_face && this_face->box != FACE_NO_BOX
  8906           && (!next_face || next_face->box == FACE_NO_BOX))
  8907         it->end_of_box_run_p = true;
  8908       it->face_box_p = this_face && this_face->box != FACE_NO_BOX;
  8909     }
  8910   else
  8911     /* Display table entry is invalid.  Return a space.  */
  8912     it->c = ' ', it->len = 1;
  8913 
  8914   /* Don't change position and object of the iterator here.  They are
  8915      still the values of the character that had this display table
  8916      entry or was translated, and that's what we want.  */
  8917   it->what = IT_CHARACTER;
  8918   return true;
  8919 }
  8920 
  8921 /* Get the first element of string/buffer in the visual order, after
  8922    being reseated to a new position in a string or a buffer.  */
  8923 static void
  8924 get_visually_first_element (struct it *it)
  8925 {
  8926   bool string_p = STRINGP (it->string) || it->s;
  8927   ptrdiff_t eob = (string_p ? it->bidi_it.string.schars : ZV);
  8928   ptrdiff_t bob;
  8929   ptrdiff_t obegv = BEGV;
  8930 
  8931   SET_WITH_NARROWED_BEGV (it, bob,
  8932                           string_p ? 0 :
  8933                           IT_CHARPOS (*it) < BEGV ? obegv : BEGV,
  8934                           it->medium_narrowing_begv);
  8935 
  8936   if (STRINGP (it->string))
  8937     {
  8938       it->bidi_it.charpos = IT_STRING_CHARPOS (*it);
  8939       it->bidi_it.bytepos = IT_STRING_BYTEPOS (*it);
  8940     }
  8941   else
  8942     {
  8943       it->bidi_it.charpos = IT_CHARPOS (*it);
  8944       it->bidi_it.bytepos = IT_BYTEPOS (*it);
  8945     }
  8946 
  8947   if (it->bidi_it.charpos == eob)
  8948     {
  8949       /* Nothing to do, but reset the FIRST_ELT flag, like
  8950          bidi_paragraph_init does, because we are not going to
  8951          call it.  */
  8952       it->bidi_it.first_elt = false;
  8953     }
  8954   else if (it->bidi_it.charpos == bob
  8955            || (!string_p
  8956                && (FETCH_BYTE (it->bidi_it.bytepos - 1) == '\n'
  8957                    || FETCH_BYTE (it->bidi_it.bytepos) == '\n')))
  8958     {
  8959       /* If we are at the beginning of a line/string, we can produce
  8960          the next element right away.  */
  8961       bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, true);
  8962       bidi_move_to_visually_next (&it->bidi_it);
  8963     }
  8964   else
  8965     {
  8966       ptrdiff_t orig_bytepos = it->bidi_it.bytepos;
  8967 
  8968       /* We need to prime the bidi iterator starting at the line's or
  8969          string's beginning, before we will be able to produce the
  8970          next element.  */
  8971       if (string_p)
  8972         it->bidi_it.charpos = it->bidi_it.bytepos = 0;
  8973       else
  8974         SET_WITH_NARROWED_BEGV (it, it->bidi_it.charpos,
  8975                                 find_newline_no_quit (IT_CHARPOS (*it),
  8976                                                       IT_BYTEPOS (*it), -1,
  8977                                                       &it->bidi_it.bytepos),
  8978                                 it->medium_narrowing_begv);
  8979       bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, true);
  8980       do
  8981         {
  8982           /* Now return to buffer/string position where we were asked
  8983              to get the next display element, and produce that.  */
  8984           bidi_move_to_visually_next (&it->bidi_it);
  8985         }
  8986       while (it->bidi_it.bytepos != orig_bytepos
  8987              && it->bidi_it.charpos < eob);
  8988     }
  8989 
  8990   /*  Adjust IT's position information to where we ended up.  */
  8991   if (STRINGP (it->string))
  8992     {
  8993       IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
  8994       IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
  8995     }
  8996   else
  8997     {
  8998       IT_CHARPOS (*it) = it->bidi_it.charpos;
  8999       IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  9000     }
  9001 
  9002   if (STRINGP (it->string) || !it->s)
  9003     {
  9004       ptrdiff_t stop, charpos, bytepos;
  9005 
  9006       if (STRINGP (it->string))
  9007         {
  9008           eassert (!it->s);
  9009           stop = SCHARS (it->string);
  9010           if (stop > it->end_charpos)
  9011             stop = it->end_charpos;
  9012           charpos = IT_STRING_CHARPOS (*it);
  9013           bytepos = IT_STRING_BYTEPOS (*it);
  9014         }
  9015       else
  9016         {
  9017           stop = it->end_charpos;
  9018           charpos = IT_CHARPOS (*it);
  9019           bytepos = IT_BYTEPOS (*it);
  9020         }
  9021       if (it->bidi_it.scan_dir < 0)
  9022         stop = -1;
  9023       composition_compute_stop_pos (&it->cmp_it, charpos, bytepos, stop,
  9024                                     it->string, true);
  9025     }
  9026 }
  9027 
  9028 /* Load IT with the next display element from Lisp string IT->string.
  9029    IT->current.string_pos is the current position within the string.
  9030    If IT->current.overlay_string_index >= 0, the Lisp string is an
  9031    overlay string.  */
  9032 
  9033 static bool
  9034 next_element_from_string (struct it *it)
  9035 {
  9036   struct text_pos position;
  9037 
  9038   eassert (STRINGP (it->string));
  9039   eassert (!it->bidi_p || EQ (it->string, it->bidi_it.string.lstring));
  9040   eassert (IT_STRING_CHARPOS (*it) >= 0);
  9041   position = it->current.string_pos;
  9042 
  9043   /* With bidi reordering, the character to display might not be the
  9044      character at IT_STRING_CHARPOS.  BIDI_IT.FIRST_ELT means
  9045      that we were reseat()ed to a new string, whose paragraph
  9046      direction is not known.  */
  9047   if (it->bidi_p && it->bidi_it.first_elt)
  9048     {
  9049       get_visually_first_element (it);
  9050       SET_TEXT_POS (position, IT_STRING_CHARPOS (*it), IT_STRING_BYTEPOS (*it));
  9051     }
  9052 
  9053   /* Time to check for invisible text?  */
  9054   if (IT_STRING_CHARPOS (*it) < it->end_charpos)
  9055     {
  9056       if (IT_STRING_CHARPOS (*it) >= it->stop_charpos)
  9057         {
  9058           if (!(!it->bidi_p
  9059                 || BIDI_AT_BASE_LEVEL (it->bidi_it)
  9060                 || IT_STRING_CHARPOS (*it) == it->stop_charpos))
  9061             {
  9062               /* With bidi non-linear iteration, we could find
  9063                  ourselves far beyond the last computed stop_charpos,
  9064                  with several other stop positions in between that we
  9065                  missed.  Scan them all now, in buffer's logical
  9066                  order, until we find and handle the last stop_charpos
  9067                  that precedes our current position.  */
  9068               handle_stop_backwards (it, it->stop_charpos);
  9069               return GET_NEXT_DISPLAY_ELEMENT (it);
  9070             }
  9071           else
  9072             {
  9073               if (it->bidi_p)
  9074                 {
  9075                   /* Take note of the stop position we just moved
  9076                      across, for when we will move back across it.  */
  9077                   it->prev_stop = it->stop_charpos;
  9078                   /* If we are at base paragraph embedding level, take
  9079                      note of the last stop position seen at this
  9080                      level.  */
  9081                   if (BIDI_AT_BASE_LEVEL (it->bidi_it))
  9082                     it->base_level_stop = it->stop_charpos;
  9083                 }
  9084               handle_stop (it);
  9085 
  9086               /* Since a handler may have changed IT->method, we must
  9087                  recurse here.  */
  9088               return GET_NEXT_DISPLAY_ELEMENT (it);
  9089             }
  9090         }
  9091       else if (it->bidi_p
  9092                /* If we are before prev_stop, we may have overstepped
  9093                   on our way backwards a stop_pos, and if so, we need
  9094                   to handle that stop_pos.  */
  9095                && IT_STRING_CHARPOS (*it) < it->prev_stop
  9096                /* We can sometimes back up for reasons that have nothing
  9097                   to do with bidi reordering.  E.g., compositions.  The
  9098                   code below is only needed when we are above the base
  9099                   embedding level, so test for that explicitly.  */
  9100                && !BIDI_AT_BASE_LEVEL (it->bidi_it))
  9101         {
  9102           /* If we lost track of base_level_stop, we have no better
  9103              place for handle_stop_backwards to start from than string
  9104              beginning.  This happens, e.g., when we were reseated to
  9105              the previous screenful of text by vertical-motion.  */
  9106           if (it->base_level_stop <= 0
  9107               || IT_STRING_CHARPOS (*it) < it->base_level_stop)
  9108             it->base_level_stop = 0;
  9109           handle_stop_backwards (it, it->base_level_stop);
  9110           return GET_NEXT_DISPLAY_ELEMENT (it);
  9111         }
  9112     }
  9113 
  9114   if (it->current.overlay_string_index >= 0)
  9115     {
  9116       /* Get the next character from an overlay string.  In overlay
  9117          strings, there is no field width or padding with spaces to
  9118          do.  */
  9119       if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
  9120         {
  9121           it->what = IT_EOB;
  9122           return false;
  9123         }
  9124       else if (CHAR_COMPOSED_P (it, IT_STRING_CHARPOS (*it),
  9125                                 IT_STRING_BYTEPOS (*it),
  9126                                 it->bidi_it.scan_dir < 0
  9127                                 ? -1
  9128                                 : SCHARS (it->string))
  9129                && next_element_from_composition (it))
  9130         {
  9131           return true;
  9132         }
  9133       else if (STRING_MULTIBYTE (it->string))
  9134         {
  9135           const unsigned char *s = (SDATA (it->string)
  9136                                     + IT_STRING_BYTEPOS (*it));
  9137           it->c = check_char_and_length (s, &it->len);
  9138         }
  9139       else
  9140         {
  9141           it->c = SREF (it->string, IT_STRING_BYTEPOS (*it));
  9142           it->len = 1;
  9143         }
  9144     }
  9145   else
  9146     {
  9147       /* Get the next character from a Lisp string that is not an
  9148          overlay string.  Such strings come from the mode line, for
  9149          example.  We may have to pad with spaces, or truncate the
  9150          string.  See also next_element_from_c_string.  */
  9151       if (IT_STRING_CHARPOS (*it) >= it->end_charpos)
  9152         {
  9153           it->what = IT_EOB;
  9154           return false;
  9155         }
  9156       else if (IT_STRING_CHARPOS (*it) >= it->string_nchars)
  9157         {
  9158           /* Pad with spaces.  */
  9159           it->c = ' ', it->len = 1;
  9160           CHARPOS (position) = BYTEPOS (position) = -1;
  9161         }
  9162       else if (CHAR_COMPOSED_P (it, IT_STRING_CHARPOS (*it),
  9163                                 IT_STRING_BYTEPOS (*it),
  9164                                 it->bidi_it.scan_dir < 0
  9165                                 ? -1
  9166                                 : it->string_nchars)
  9167                && next_element_from_composition (it))
  9168         {
  9169           return true;
  9170         }
  9171       else if (STRING_MULTIBYTE (it->string))
  9172         {
  9173           const unsigned char *s = (SDATA (it->string)
  9174                                     + IT_STRING_BYTEPOS (*it));
  9175           it->c = check_char_and_length (s, &it->len);
  9176         }
  9177       else
  9178         {
  9179           it->c = SREF (it->string, IT_STRING_BYTEPOS (*it));
  9180           it->len = 1;
  9181         }
  9182     }
  9183 
  9184   /* Record what we have and where it came from.  */
  9185   it->what = IT_CHARACTER;
  9186   it->object = it->string;
  9187   it->position = position;
  9188   return true;
  9189 }
  9190 
  9191 
  9192 /* Load IT with next display element from C string IT->s.
  9193    IT->string_nchars is the maximum number of characters to return
  9194    from the string.  IT->end_charpos may be greater than
  9195    IT->string_nchars when this function is called, in which case we
  9196    may have to return padding spaces.  Value is false if end of string
  9197    reached, including padding spaces.  */
  9198 
  9199 static bool
  9200 next_element_from_c_string (struct it *it)
  9201 {
  9202   bool success_p = true;
  9203 
  9204   eassert (it->s);
  9205   eassert (!it->bidi_p || it->s == it->bidi_it.string.s);
  9206   it->what = IT_CHARACTER;
  9207   BYTEPOS (it->position) = CHARPOS (it->position) = 0;
  9208   it->object = make_fixnum (0);
  9209 
  9210   /* With bidi reordering, the character to display might not be the
  9211      character at IT_CHARPOS.  BIDI_IT.FIRST_ELT means that
  9212      we were reseated to a new string, whose paragraph direction is
  9213      not known.  */
  9214   if (it->bidi_p && it->bidi_it.first_elt)
  9215     get_visually_first_element (it);
  9216 
  9217   /* IT's position can be greater than IT->string_nchars in case a
  9218      field width or precision has been specified when the iterator was
  9219      initialized.  */
  9220   if (IT_CHARPOS (*it) >= it->end_charpos)
  9221     {
  9222       /* End of the game.  */
  9223       it->what = IT_EOB;
  9224       success_p = false;
  9225     }
  9226   else if (IT_CHARPOS (*it) >= it->string_nchars)
  9227     {
  9228       /* Pad with spaces.  */
  9229       it->c = ' ', it->len = 1;
  9230       BYTEPOS (it->position) = CHARPOS (it->position) = -1;
  9231     }
  9232   else if (it->multibyte_p)
  9233     it->c = check_char_and_length (it->s + IT_BYTEPOS (*it), &it->len);
  9234   else
  9235     it->c = it->s[IT_BYTEPOS (*it)], it->len = 1;
  9236 
  9237   return success_p;
  9238 }
  9239 
  9240 
  9241 /* Set up IT to return characters from an ellipsis, if appropriate.
  9242    The definition of the ellipsis glyphs may come from a display table
  9243    entry.  This function fills IT with the first glyph from the
  9244    ellipsis if an ellipsis is to be displayed.  */
  9245 
  9246 static bool
  9247 next_element_from_ellipsis (struct it *it)
  9248 {
  9249   if (it->selective_display_ellipsis_p)
  9250     setup_for_ellipsis (it, it->len);
  9251   else
  9252     {
  9253       /* The face at the current position may be different from the
  9254          face we find after the invisible text.  Remember what it
  9255          was in IT->saved_face_id, and signal that it's there by
  9256          setting face_before_selective_p.  */
  9257       it->saved_face_id = it->face_id;
  9258       it->method = GET_FROM_BUFFER;
  9259       it->object = it->w->contents;
  9260       reseat_at_next_visible_line_start (it, true);
  9261       it->face_before_selective_p = true;
  9262     }
  9263 
  9264   return GET_NEXT_DISPLAY_ELEMENT (it);
  9265 }
  9266 
  9267 
  9268 /* Deliver an image display element.  The iterator IT is already
  9269    filled with image information (done in handle_display_prop).  Value
  9270    is always true.  */
  9271 
  9272 
  9273 static bool
  9274 next_element_from_image (struct it *it)
  9275 {
  9276   it->what = IT_IMAGE;
  9277   return true;
  9278 }
  9279 
  9280 static bool
  9281 next_element_from_xwidget (struct it *it)
  9282 {
  9283   it->what = IT_XWIDGET;
  9284   return true;
  9285 }
  9286 
  9287 
  9288 /* Fill iterator IT with next display element from a stretch glyph
  9289    property.  IT->object is the value of the text property.  Value is
  9290    always true.  */
  9291 
  9292 static bool
  9293 next_element_from_stretch (struct it *it)
  9294 {
  9295   it->what = IT_STRETCH;
  9296   return true;
  9297 }
  9298 
  9299 /* Scan backwards from IT's current position until we find a stop
  9300    position, or until BEGV.  This is called when we find ourself
  9301    before both the last known prev_stop and base_level_stop while
  9302    reordering bidirectional text.  */
  9303 
  9304 static void
  9305 compute_stop_pos_backwards (struct it *it)
  9306 {
  9307   const int SCAN_BACK_LIMIT = 1000;
  9308   struct text_pos pos;
  9309   struct display_pos save_current = it->current;
  9310   struct text_pos save_position = it->position;
  9311   ptrdiff_t charpos = IT_CHARPOS (*it);
  9312   ptrdiff_t where_we_are = charpos;
  9313   ptrdiff_t save_stop_pos = it->stop_charpos;
  9314   ptrdiff_t save_end_pos = it->end_charpos;
  9315 
  9316   eassert (NILP (it->string) && !it->s);
  9317   eassert (it->bidi_p);
  9318   it->bidi_p = false;
  9319   do
  9320     {
  9321       it->end_charpos = min (charpos + 1, ZV);
  9322       charpos = max (charpos - SCAN_BACK_LIMIT, BEGV);
  9323       SET_TEXT_POS (pos, charpos, CHAR_TO_BYTE (charpos));
  9324       reseat_1 (it, pos, false);
  9325       compute_stop_pos (it);
  9326       /* We must advance forward, right?  */
  9327       if (it->stop_charpos <= charpos)
  9328         emacs_abort ();
  9329     }
  9330   while (charpos > BEGV && it->stop_charpos >= it->end_charpos);
  9331 
  9332   if (it->stop_charpos <= where_we_are)
  9333     it->prev_stop = it->stop_charpos;
  9334   else
  9335     it->prev_stop = BEGV;
  9336   it->bidi_p = true;
  9337   it->current = save_current;
  9338   it->position = save_position;
  9339   it->stop_charpos = save_stop_pos;
  9340   it->end_charpos = save_end_pos;
  9341 }
  9342 
  9343 /* Scan forward from CHARPOS in the current buffer/string, until we
  9344    find a stop position > current IT's position.  Then handle the stop
  9345    position before that.  This is called when we bump into a stop
  9346    position while reordering bidirectional text.  CHARPOS should be
  9347    the last previously processed stop_pos (or BEGV/0, if none were
  9348    processed yet) whose position is less than IT's current
  9349    position.  */
  9350 
  9351 static void
  9352 handle_stop_backwards (struct it *it, ptrdiff_t charpos)
  9353 {
  9354   bool bufp = !STRINGP (it->string);
  9355   ptrdiff_t where_we_are = (bufp ? IT_CHARPOS (*it) : IT_STRING_CHARPOS (*it));
  9356   struct display_pos save_current = it->current;
  9357   struct text_pos save_position = it->position;
  9358   struct composition_it save_cmp_it = it->cmp_it;
  9359   struct text_pos pos1;
  9360   ptrdiff_t next_stop;
  9361 
  9362   /* Scan in strict logical order.  */
  9363   eassert (it->bidi_p);
  9364   it->bidi_p = false;
  9365   do
  9366     {
  9367       it->prev_stop = charpos;
  9368       if (bufp)
  9369         {
  9370           SET_TEXT_POS (pos1, charpos, CHAR_TO_BYTE (charpos));
  9371           reseat_1 (it, pos1, false);
  9372         }
  9373       else
  9374         it->current.string_pos = string_pos (charpos, it->string);
  9375       compute_stop_pos (it);
  9376       /* We must advance forward, right?  */
  9377       if (it->stop_charpos <= it->prev_stop)
  9378         emacs_abort ();
  9379       charpos = it->stop_charpos;
  9380     }
  9381   while (charpos <= where_we_are);
  9382 
  9383   it->bidi_p = true;
  9384   it->current = save_current;
  9385   it->position = save_position;
  9386   it->cmp_it = save_cmp_it;
  9387   next_stop = it->stop_charpos;
  9388   it->stop_charpos = it->prev_stop;
  9389   handle_stop (it);
  9390   it->stop_charpos = next_stop;
  9391 }
  9392 
  9393 /* Load IT with the next display element from current_buffer.  Value
  9394    is false if end of buffer reached.  IT->stop_charpos is the next
  9395    position at which to stop and check for text properties or buffer
  9396    end.  */
  9397 
  9398 static bool
  9399 next_element_from_buffer (struct it *it)
  9400 {
  9401   bool success_p = true;
  9402 
  9403   eassert (IT_CHARPOS (*it) >= BEGV);
  9404   eassert (NILP (it->string) && !it->s);
  9405   eassert (!it->bidi_p
  9406            || (NILP (it->bidi_it.string.lstring)
  9407                && it->bidi_it.string.s == NULL));
  9408 
  9409   /* With bidi reordering, the character to display might not be the
  9410      character at IT_CHARPOS.  BIDI_IT.FIRST_ELT means that
  9411      we were reseat()ed to a new buffer position, which is potentially
  9412      a different paragraph.  */
  9413   if (it->bidi_p && it->bidi_it.first_elt)
  9414     {
  9415       get_visually_first_element (it);
  9416       SET_TEXT_POS (it->position, IT_CHARPOS (*it), IT_BYTEPOS (*it));
  9417     }
  9418 
  9419   if (IT_CHARPOS (*it) >= it->stop_charpos)
  9420     {
  9421       if (IT_CHARPOS (*it) >= it->end_charpos)
  9422         {
  9423           bool overlay_strings_follow_p;
  9424 
  9425           /* End of the game, except when overlay strings follow that
  9426              haven't been returned yet.  */
  9427           if (it->overlay_strings_at_end_processed_p)
  9428             overlay_strings_follow_p = false;
  9429           else
  9430             {
  9431               it->overlay_strings_at_end_processed_p = true;
  9432               overlay_strings_follow_p = get_overlay_strings (it, 0);
  9433             }
  9434 
  9435           if (overlay_strings_follow_p)
  9436             success_p = GET_NEXT_DISPLAY_ELEMENT (it);
  9437           else
  9438             {
  9439               it->what = IT_EOB;
  9440               it->position = it->current.pos;
  9441               success_p = false;
  9442             }
  9443         }
  9444       else if (!(!it->bidi_p
  9445                  || BIDI_AT_BASE_LEVEL (it->bidi_it)
  9446                  || IT_CHARPOS (*it) == it->stop_charpos))
  9447         {
  9448           /* With bidi non-linear iteration, we could find ourselves
  9449              far beyond the last computed stop_charpos, with several
  9450              other stop positions in between that we missed.  Scan
  9451              them all now, in buffer's logical order, until we find
  9452              and handle the last stop_charpos that precedes our
  9453              current position.  */
  9454           handle_stop_backwards (it, it->stop_charpos);
  9455           it->ignore_overlay_strings_at_pos_p = false;
  9456           return GET_NEXT_DISPLAY_ELEMENT (it);
  9457         }
  9458       else
  9459         {
  9460           if (it->bidi_p)
  9461             {
  9462               /* Take note of the stop position we just moved across,
  9463                  for when we will move back across it.  */
  9464               it->prev_stop = it->stop_charpos;
  9465               /* If we are at base paragraph embedding level, take
  9466                  note of the last stop position seen at this
  9467                  level.  */
  9468               if (BIDI_AT_BASE_LEVEL (it->bidi_it))
  9469                 it->base_level_stop = it->stop_charpos;
  9470             }
  9471           handle_stop (it);
  9472           it->ignore_overlay_strings_at_pos_p = false;
  9473           return GET_NEXT_DISPLAY_ELEMENT (it);
  9474         }
  9475     }
  9476   else if (it->bidi_p
  9477            /* If we are before prev_stop, we may have overstepped on
  9478               our way backwards a stop_pos, and if so, we need to
  9479               handle that stop_pos.  */
  9480            && IT_CHARPOS (*it) < it->prev_stop
  9481            /* We can sometimes back up for reasons that have nothing
  9482               to do with bidi reordering.  E.g., compositions.  The
  9483               code below is only needed when we are above the base
  9484               embedding level, so test for that explicitly.  */
  9485            && !BIDI_AT_BASE_LEVEL (it->bidi_it))
  9486     {
  9487       if (it->base_level_stop <= 0
  9488           || IT_CHARPOS (*it) < it->base_level_stop)
  9489         {
  9490           /* If we lost track of base_level_stop, we need to find
  9491              prev_stop by looking backwards.  This happens, e.g., when
  9492              we were reseated to the previous screenful of text by
  9493              vertical-motion.  */
  9494           it->base_level_stop = BEGV;
  9495           compute_stop_pos_backwards (it);
  9496           handle_stop_backwards (it, it->prev_stop);
  9497         }
  9498       else
  9499         handle_stop_backwards (it, it->base_level_stop);
  9500       it->ignore_overlay_strings_at_pos_p = false;
  9501       return GET_NEXT_DISPLAY_ELEMENT (it);
  9502     }
  9503   else
  9504     {
  9505       /* No face changes, overlays etc. in sight, so just return a
  9506          character from current_buffer.  */
  9507       unsigned char *p;
  9508       ptrdiff_t stop;
  9509 
  9510       /* We moved to the next buffer position, so any info about
  9511          previously seen overlays is no longer valid.  */
  9512       it->ignore_overlay_strings_at_pos_p = false;
  9513 
  9514       if (composition_break_at_point
  9515           && !NILP (BVAR (current_buffer, enable_multibyte_characters))
  9516           && !NILP (Vauto_composition_mode))
  9517         {
  9518           /* Limit search for composable characters to point's position.  */
  9519           if (it->bidi_it.scan_dir < 0)
  9520             stop = (PT <= IT_CHARPOS (*it)) ? PT : -1;
  9521           else
  9522             stop = (IT_CHARPOS (*it) < PT
  9523                     && PT < it->end_charpos) ? PT : it->end_charpos;
  9524         }
  9525       else
  9526         stop = it->bidi_it.scan_dir < 0 ? -1 : it->end_charpos;
  9527       if (CHAR_COMPOSED_P (it, IT_CHARPOS (*it), IT_BYTEPOS (*it),
  9528                            stop)
  9529           && next_element_from_composition (it))
  9530         {
  9531           return true;
  9532         }
  9533 
  9534       /* Get the next character, maybe multibyte.  */
  9535       p = BYTE_POS_ADDR (IT_BYTEPOS (*it));
  9536       if (it->multibyte_p && !ASCII_CHAR_P (*p))
  9537         it->c = string_char_and_length (p, &it->len);
  9538       else
  9539         it->c = *p, it->len = 1;
  9540 
  9541       /* Record what we have and where it came from.  */
  9542       it->what = IT_CHARACTER;
  9543       it->object = it->w->contents;
  9544       it->position = it->current.pos;
  9545 
  9546       /* Normally we return the character found above, except when we
  9547          really want to return an ellipsis for selective display.  */
  9548       if (it->selective)
  9549         {
  9550           if (it->c == '\n')
  9551             {
  9552               /* A value of selective > 0 means hide lines indented more
  9553                  than that number of columns.  */
  9554               if (it->selective > 0
  9555                   && IT_CHARPOS (*it) + 1 < ZV
  9556                   && indented_beyond_p (IT_CHARPOS (*it) + 1,
  9557                                         IT_BYTEPOS (*it) + 1,
  9558                                         it->selective))
  9559                 {
  9560                   success_p = next_element_from_ellipsis (it);
  9561                   it->dpvec_char_len = -1;
  9562                 }
  9563             }
  9564           else if (it->c == '\r' && it->selective == -1)
  9565             {
  9566               /* A value of selective == -1 means that everything from the
  9567                  CR to the end of the line is invisible, with maybe an
  9568                  ellipsis displayed for it.  */
  9569               success_p = next_element_from_ellipsis (it);
  9570               it->dpvec_char_len = -1;
  9571             }
  9572         }
  9573     }
  9574 
  9575   /* Value is false if end of buffer reached.  */
  9576   eassert (!success_p || it->what != IT_CHARACTER || it->len > 0);
  9577   return success_p;
  9578 }
  9579 
  9580 
  9581 /* Deliver a composition display element.  Unlike the other
  9582    next_element_from_XXX, this function is not registered in the array
  9583    get_next_element[].  It is called from next_element_from_buffer and
  9584    next_element_from_string when necessary.  */
  9585 
  9586 static bool
  9587 next_element_from_composition (struct it *it)
  9588 {
  9589   it->what = IT_COMPOSITION;
  9590   it->len = it->cmp_it.nbytes;
  9591   if (STRINGP (it->string))
  9592     {
  9593       if (it->c < 0)
  9594         {
  9595           IT_STRING_CHARPOS (*it) += it->cmp_it.nchars;
  9596           IT_STRING_BYTEPOS (*it) += it->cmp_it.nbytes;
  9597           return false;
  9598         }
  9599       it->position = it->current.string_pos;
  9600       it->object = it->string;
  9601       it->c = composition_update_it (&it->cmp_it, IT_STRING_CHARPOS (*it),
  9602                                      IT_STRING_BYTEPOS (*it), it->string);
  9603     }
  9604   else
  9605     {
  9606       if (it->c < 0)
  9607         {
  9608           IT_CHARPOS (*it) += it->cmp_it.nchars;
  9609           IT_BYTEPOS (*it) += it->cmp_it.nbytes;
  9610           if (it->bidi_p)
  9611             {
  9612               if (it->bidi_it.new_paragraph)
  9613                 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it,
  9614                                      false);
  9615               /* Resync the bidi iterator with IT's new position.
  9616                  FIXME: this doesn't support bidirectional text.  */
  9617               while (it->bidi_it.charpos < IT_CHARPOS (*it))
  9618                 bidi_move_to_visually_next (&it->bidi_it);
  9619             }
  9620           return false;
  9621         }
  9622       it->position = it->current.pos;
  9623       it->object = it->w->contents;
  9624       it->c = composition_update_it (&it->cmp_it, IT_CHARPOS (*it),
  9625                                      IT_BYTEPOS (*it), Qnil);
  9626     }
  9627   return true;
  9628 }
  9629 
  9630 
  9631 
  9632 /***********************************************************************
  9633              Moving an iterator without producing glyphs
  9634  ***********************************************************************/
  9635 
  9636 /* Check if iterator is at a position corresponding to a valid buffer
  9637    position after some move_it_ call.  */
  9638 
  9639 #define IT_POS_VALID_AFTER_MOVE_P(it)                   \
  9640   ((it)->method != GET_FROM_STRING || IT_STRING_CHARPOS (*it) == 0)
  9641 
  9642 
  9643 /* Move iterator IT to a specified buffer or X position within one
  9644    line on the display without producing glyphs.
  9645 
  9646    OP should be a bit mask including some or all of these bits:
  9647     MOVE_TO_X: Stop upon reaching x-position TO_X.
  9648     MOVE_TO_POS: Stop upon reaching buffer or string position TO_CHARPOS.
  9649    Regardless of OP's value, stop upon reaching the end of the display line.
  9650 
  9651    TO_X is normally a value 0 <= TO_X <= IT->last_visible_x.
  9652    This means, in particular, that TO_X includes window's horizontal
  9653    scroll amount.
  9654 
  9655    The return value has several possible values that
  9656    say what condition caused the scan to stop:
  9657 
  9658    MOVE_POS_MATCH_OR_ZV
  9659      - when TO_POS or ZV was reached.
  9660 
  9661    MOVE_X_REACHED
  9662      -when TO_X was reached before TO_POS or ZV were reached.
  9663 
  9664    MOVE_LINE_CONTINUED
  9665      - when we reached the end of the display area and the line must
  9666      be continued.
  9667 
  9668    MOVE_LINE_TRUNCATED
  9669      - when we reached the end of the display area and the line is
  9670      truncated.
  9671 
  9672    MOVE_NEWLINE_OR_CR
  9673      - when we stopped at a line end, i.e. a newline or a CR and selective
  9674      display is on.  */
  9675 
  9676 static enum move_it_result
  9677 move_it_in_display_line_to (struct it *it,
  9678                             ptrdiff_t to_charpos, int to_x,
  9679                             enum move_operation_enum op)
  9680 {
  9681   enum move_it_result result = MOVE_UNDEFINED;
  9682   struct glyph_row *saved_glyph_row;
  9683   struct it wrap_it, atpos_it, atx_it, ppos_it;
  9684   void *wrap_data = NULL, *atpos_data = NULL, *atx_data = NULL;
  9685   void *ppos_data = NULL;
  9686   bool may_wrap = false;
  9687   enum it_method prev_method = it->method;
  9688   ptrdiff_t closest_pos UNINIT;
  9689   ptrdiff_t prev_pos = IT_CHARPOS (*it);
  9690   bool saw_smaller_pos = prev_pos < to_charpos;
  9691   bool line_number_pending = false;
  9692 
  9693   /* Don't produce glyphs in produce_glyphs.  */
  9694   saved_glyph_row = it->glyph_row;
  9695   it->glyph_row = NULL;
  9696 
  9697   /* Use wrap_it to save a copy of IT wherever a word wrap could
  9698      occur.  Use atpos_it to save a copy of IT at the desired buffer
  9699      position, if found, so that we can scan ahead and check if the
  9700      word later overshoots the window edge.  Use atx_it similarly, for
  9701      pixel positions.  */
  9702   wrap_it.sp = -1;
  9703   atpos_it.sp = -1;
  9704   atx_it.sp = -1;
  9705 
  9706   /* Use ppos_it under bidi reordering to save a copy of IT for the
  9707      initial position.  We restore that position in IT when we have
  9708      scanned the entire display line without finding a match for
  9709      TO_CHARPOS and all the character positions are greater than
  9710      TO_CHARPOS.  We then restart the scan from the initial position,
  9711      and stop at CLOSEST_POS, which is a position > TO_CHARPOS that is
  9712      the closest to TO_CHARPOS.  */
  9713   if (it->bidi_p)
  9714     {
  9715       if ((op & MOVE_TO_POS) && IT_CHARPOS (*it) >= to_charpos)
  9716         {
  9717           SAVE_IT (ppos_it, *it, ppos_data);
  9718           closest_pos = IT_CHARPOS (*it);
  9719         }
  9720       else
  9721         closest_pos = ZV;
  9722     }
  9723 
  9724 #define BUFFER_POS_REACHED_P()                                  \
  9725   ((op & MOVE_TO_POS) != 0                                      \
  9726    && BUFFERP (it->object)                                      \
  9727    && (IT_CHARPOS (*it) == to_charpos                           \
  9728        || ((!it->bidi_p                                         \
  9729             || BIDI_AT_BASE_LEVEL (it->bidi_it))                \
  9730            && IT_CHARPOS (*it) > to_charpos)                    \
  9731        || (it->what == IT_COMPOSITION                           \
  9732            && ((IT_CHARPOS (*it) > to_charpos                   \
  9733                 && to_charpos >= it->cmp_it.charpos)            \
  9734                || (IT_CHARPOS (*it) < to_charpos                \
  9735                    && to_charpos <= it->cmp_it.charpos))))      \
  9736    && (it->method == GET_FROM_BUFFER                            \
  9737        || (it->method == GET_FROM_DISPLAY_VECTOR                \
  9738            && it->dpvec + it->current.dpvec_index + 1 >= it->dpend)))
  9739 
  9740   if (it->hpos == 0)
  9741     {
  9742       /* If line numbers are being displayed, produce a line number.
  9743          But don't do that if we are to reach first_visible_x, because
  9744          line numbers are not relevant to stuff that is not visible on
  9745          display.  */
  9746       if (!((op && MOVE_TO_X) && to_x == it->first_visible_x)
  9747           && should_produce_line_number (it))
  9748         {
  9749           if (it->current_x == it->first_visible_x)
  9750             maybe_produce_line_number (it);
  9751           else
  9752             line_number_pending = true;
  9753         }
  9754       /* If there's a line-/wrap-prefix, handle it, if we didn't already.  */
  9755       if (it->area == TEXT_AREA && !it->string_from_prefix_prop_p)
  9756         handle_line_prefix (it);
  9757     }
  9758 
  9759   if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
  9760     SET_TEXT_POS (this_line_min_pos, IT_CHARPOS (*it), IT_BYTEPOS (*it));
  9761 
  9762   while (true)
  9763     {
  9764       int x, i, ascent = 0, descent = 0;
  9765 
  9766 /* Utility macro to reset an iterator with x, ascent, and descent.  */
  9767 #define IT_RESET_X_ASCENT_DESCENT(IT)                   \
  9768   ((IT)->current_x = x, (IT)->max_ascent = ascent,      \
  9769    (IT)->max_descent = descent)
  9770 
  9771       /* Stop if we move beyond TO_CHARPOS (after an image or a
  9772          display string or stretch glyph).  */
  9773       if ((op & MOVE_TO_POS) != 0
  9774           && BUFFERP (it->object)
  9775           && it->method == GET_FROM_BUFFER
  9776           && (((!it->bidi_p
  9777                 /* When the iterator is at base embedding level, we
  9778                    are guaranteed that characters are delivered for
  9779                    display in strictly increasing order of their
  9780                    buffer positions.  */
  9781                 || BIDI_AT_BASE_LEVEL (it->bidi_it))
  9782                && IT_CHARPOS (*it) > to_charpos)
  9783               || (it->bidi_p
  9784                   && (prev_method == GET_FROM_IMAGE
  9785                       || prev_method == GET_FROM_STRETCH
  9786                       || prev_method == GET_FROM_STRING)
  9787                   /* Passed TO_CHARPOS from left to right.  */
  9788                   && ((prev_pos < to_charpos
  9789                        && IT_CHARPOS (*it) >= to_charpos)
  9790                       /* Passed TO_CHARPOS from right to left.  */
  9791                       || (prev_pos > to_charpos
  9792                           && IT_CHARPOS (*it) <= to_charpos)))))
  9793         {
  9794           if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
  9795             {
  9796               result = MOVE_POS_MATCH_OR_ZV;
  9797               break;
  9798             }
  9799           else if (it->line_wrap == WORD_WRAP && atpos_it.sp < 0)
  9800             /* If wrap_it is valid, the current position might be in a
  9801                word that is wrapped.  So, save the iterator in
  9802                atpos_it and continue to see if wrapping happens.  */
  9803             SAVE_IT (atpos_it, *it, atpos_data);
  9804         }
  9805 
  9806       /* Stop when ZV reached.
  9807          We used to stop here when TO_CHARPOS reached as well, but that is
  9808          too soon if this glyph does not fit on this line.  So we handle it
  9809          explicitly below.  */
  9810       if (!get_next_display_element (it))
  9811         {
  9812           result = MOVE_POS_MATCH_OR_ZV;
  9813           break;
  9814         }
  9815 
  9816       if (it->line_wrap == TRUNCATE)
  9817         {
  9818           /* If it->pixel_width is zero, the last PRODUCE_GLYPHS call
  9819              produced something that doesn't consume any screen estate
  9820              in the text area, so we don't want to exit the loop at
  9821              TO_CHARPOS, before we produce the glyph for that buffer
  9822              position.  This happens, e.g., when there's an overlay at
  9823              TO_CHARPOS that draws a fringe bitmap.  */
  9824           if (BUFFER_POS_REACHED_P ()
  9825               && (it->pixel_width > 0
  9826                   || IT_CHARPOS (*it) > to_charpos
  9827                   || it->area != TEXT_AREA))
  9828             {
  9829               result = MOVE_POS_MATCH_OR_ZV;
  9830               break;
  9831             }
  9832         }
  9833       else
  9834         {
  9835           if (it->line_wrap == WORD_WRAP && it->area == TEXT_AREA)
  9836             {
  9837               bool next_may_wrap = may_wrap;
  9838               /* Can we wrap after this character?  */
  9839               if (char_can_wrap_after (it))
  9840                 next_may_wrap = true;
  9841               else
  9842                 next_may_wrap = false;
  9843               /* Can we wrap here? */
  9844               if (may_wrap && char_can_wrap_before (it))
  9845                 {
  9846                   /* We have reached a glyph that follows one or more
  9847                      whitespace characters or characters that allow
  9848                      wrapping after them.  If this character allows
  9849                      wrapping before it, save this position as a
  9850                      wrapping point.  */
  9851                   if (atpos_it.sp >= 0)
  9852                     {
  9853                       RESTORE_IT (it, &atpos_it, atpos_data);
  9854                       result = MOVE_POS_MATCH_OR_ZV;
  9855                       goto done;
  9856                     }
  9857                   if (atx_it.sp >= 0)
  9858                     {
  9859                       RESTORE_IT (it, &atx_it, atx_data);
  9860                       result = MOVE_X_REACHED;
  9861                       goto done;
  9862                     }
  9863                   /* Otherwise, we can wrap here.  */
  9864                   SAVE_IT (wrap_it, *it, wrap_data);
  9865                 }
  9866               /* Update may_wrap for the next iteration.  */
  9867               may_wrap = next_may_wrap;
  9868             }
  9869         }
  9870 
  9871       /* Remember the line height for the current line, in case
  9872          the next element doesn't fit on the line.  */
  9873       ascent = it->max_ascent;
  9874       descent = it->max_descent;
  9875 
  9876       /* The call to produce_glyphs will get the metrics of the
  9877          display element IT is loaded with.  Record the x-position
  9878          before this display element, in case it doesn't fit on the
  9879          line.  */
  9880       x = it->current_x;
  9881 
  9882       PRODUCE_GLYPHS (it);
  9883 
  9884       if (it->area != TEXT_AREA)
  9885         {
  9886           prev_method = it->method;
  9887           if (it->method == GET_FROM_BUFFER)
  9888             prev_pos = IT_CHARPOS (*it);
  9889           set_iterator_to_next (it, true);
  9890           if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
  9891             SET_TEXT_POS (this_line_min_pos,
  9892                           IT_CHARPOS (*it), IT_BYTEPOS (*it));
  9893           if (it->bidi_p
  9894               && (op & MOVE_TO_POS)
  9895               && IT_CHARPOS (*it) > to_charpos
  9896               && IT_CHARPOS (*it) < closest_pos)
  9897             closest_pos = IT_CHARPOS (*it);
  9898           continue;
  9899         }
  9900 
  9901       /* The number of glyphs we get back in IT->nglyphs will normally
  9902          be 1 except when IT->c is (i) a TAB, or (ii) a multi-glyph
  9903          character on a terminal frame, or (iii) a line end.  For the
  9904          second case, IT->nglyphs - 1 padding glyphs will be present.
  9905          (On X frames, there is only one glyph produced for a
  9906          composite character.)
  9907 
  9908          The behavior implemented below means, for continuation lines,
  9909          that as many spaces of a TAB as fit on the current line are
  9910          displayed there.  For terminal frames, as many glyphs of a
  9911          multi-glyph character are displayed in the current line, too.
  9912          This is what the old redisplay code did, and we keep it that
  9913          way.  Under X, the whole shape of a complex character must
  9914          fit on the line or it will be completely displayed in the
  9915          next line.
  9916 
  9917          Note that both for tabs and padding glyphs, all glyphs have
  9918          the same width.  */
  9919       if (it->nglyphs)
  9920         {
  9921           /* More than one glyph or glyph doesn't fit on line.  All
  9922              glyphs have the same width.  */
  9923           int single_glyph_width = it->pixel_width / it->nglyphs;
  9924           int new_x;
  9925           int x_before_this_char = x;
  9926           int hpos_before_this_char = it->hpos;
  9927 
  9928           for (i = 0; i < it->nglyphs; ++i, x = new_x)
  9929             {
  9930               new_x = x + single_glyph_width;
  9931 
  9932               /* We want to leave anything reaching TO_X to the caller.  */
  9933               if ((op & MOVE_TO_X) && new_x > to_x)
  9934                 {
  9935                   if (BUFFER_POS_REACHED_P ())
  9936                     {
  9937                       if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
  9938                         goto buffer_pos_reached;
  9939                       if (atpos_it.sp < 0)
  9940                         {
  9941                           SAVE_IT (atpos_it, *it, atpos_data);
  9942                           IT_RESET_X_ASCENT_DESCENT (&atpos_it);
  9943                         }
  9944                     }
  9945                   else
  9946                     {
  9947                       if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
  9948                         {
  9949                           it->current_x = x;
  9950                           result = MOVE_X_REACHED;
  9951                           break;
  9952                         }
  9953                       if (atx_it.sp < 0)
  9954                         {
  9955                           SAVE_IT (atx_it, *it, atx_data);
  9956                           IT_RESET_X_ASCENT_DESCENT (&atx_it);
  9957                         }
  9958                     }
  9959                 }
  9960 
  9961               if (/* Lines are continued.  */
  9962                   it->line_wrap != TRUNCATE
  9963                   && (/* And glyph doesn't fit on the line.  */
  9964                       new_x > it->last_visible_x
  9965                       /* Or it fits exactly and we're on a window
  9966                          system frame.  */
  9967                       || (new_x == it->last_visible_x
  9968                           && FRAME_WINDOW_P (it->f)
  9969                           && ((it->bidi_p && it->bidi_it.paragraph_dir == R2L)
  9970                               ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
  9971                               : WINDOW_RIGHT_FRINGE_WIDTH (it->w)))))
  9972                 {
  9973                   bool moved_forward = false;
  9974 
  9975                   if (/* IT->hpos == 0 means the very first glyph
  9976                          doesn't fit on the line, e.g. a wide image.  */
  9977                       it->hpos == 0
  9978                       || (new_x == it->last_visible_x
  9979                           && FRAME_WINDOW_P (it->f)))
  9980                     {
  9981                       ++it->hpos;
  9982                       it->current_x = new_x;
  9983 
  9984                       /* The character's last glyph just barely fits
  9985                          in this row.  */
  9986                       if (i == it->nglyphs - 1)
  9987                         {
  9988                           /* If this is the destination position,
  9989                              return a position *before* it in this row,
  9990                              now that we know it fits in this row.  */
  9991                           if (BUFFER_POS_REACHED_P ())
  9992                             {
  9993                               bool can_wrap = true;
  9994 
  9995                               /* If the previous character says we can
  9996                                  wrap after it, but the current
  9997                                  character says we can't wrap before
  9998                                  it, then we can't wrap here.  */
  9999                               if (it->line_wrap == WORD_WRAP
 10000                                   && wrap_it.sp >= 0
 10001                                   && may_wrap
 10002                                   && IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 10003                                 {
 10004                                   struct it tem_it;
 10005                                   void *tem_data = NULL;
 10006 
 10007                                   SAVE_IT (tem_it, *it, tem_data);
 10008                                   set_iterator_to_next (it, true);
 10009                                   if (get_next_display_element (it)
 10010                                       && !char_can_wrap_before (it))
 10011                                     can_wrap = false;
 10012                                   RESTORE_IT (it, &tem_it, tem_data);
 10013                                 }
 10014                               if (it->line_wrap != WORD_WRAP
 10015                                   || wrap_it.sp < 0
 10016                                   /* If we've just found whitespace
 10017                                      where we can wrap, effectively
 10018                                      ignore the previous wrap point --
 10019                                      it is no longer relevant, but we
 10020                                      won't have an opportunity to
 10021                                      update it, since we've reached
 10022                                      the edge of this screen line.  */
 10023                                   || (may_wrap && can_wrap
 10024                                       && IT_OVERFLOW_NEWLINE_INTO_FRINGE (it)))
 10025                                 {
 10026                                   it->hpos = hpos_before_this_char;
 10027                                   it->current_x = x_before_this_char;
 10028                                   result = MOVE_POS_MATCH_OR_ZV;
 10029                                   break;
 10030                                 }
 10031                               if (it->line_wrap == WORD_WRAP
 10032                                   && atpos_it.sp < 0)
 10033                                 {
 10034                                   SAVE_IT (atpos_it, *it, atpos_data);
 10035                                   atpos_it.current_x = x_before_this_char;
 10036                                   atpos_it.hpos = hpos_before_this_char;
 10037                                 }
 10038                             }
 10039 
 10040                           prev_method = it->method;
 10041                           if (it->method == GET_FROM_BUFFER)
 10042                             prev_pos = IT_CHARPOS (*it);
 10043                           set_iterator_to_next (it, true);
 10044                           if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
 10045                             SET_TEXT_POS (this_line_min_pos,
 10046                                           IT_CHARPOS (*it), IT_BYTEPOS (*it));
 10047                           /* On graphical terminals, newlines may
 10048                              "overflow" into the fringe if
 10049                              overflow-newline-into-fringe is non-nil.
 10050                              On text terminals, and on graphical
 10051                              terminals with no right margin, newlines
 10052                              may overflow into the last glyph on the
 10053                              display line.*/
 10054                           if (!FRAME_WINDOW_P (it->f)
 10055                               || ((it->bidi_p
 10056                                    && it->bidi_it.paragraph_dir == R2L)
 10057                                   ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 10058                                   : WINDOW_RIGHT_FRINGE_WIDTH (it->w)) == 0
 10059                               || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 10060                             {
 10061                               if (!get_next_display_element (it))
 10062                                 {
 10063                                   result = MOVE_POS_MATCH_OR_ZV;
 10064                                   break;
 10065                                 }
 10066                               moved_forward = true;
 10067                               if (BUFFER_POS_REACHED_P ())
 10068                                 {
 10069                                   if (ITERATOR_AT_END_OF_LINE_P (it))
 10070                                     result = MOVE_POS_MATCH_OR_ZV;
 10071                                   else
 10072                                     result = MOVE_LINE_CONTINUED;
 10073                                   break;
 10074                                 }
 10075                               if (ITERATOR_AT_END_OF_LINE_P (it)
 10076                                   && (it->line_wrap != WORD_WRAP
 10077                                       || wrap_it.sp < 0
 10078                                       || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it)))
 10079                                 {
 10080                                   result = MOVE_NEWLINE_OR_CR;
 10081                                   break;
 10082                                 }
 10083                             }
 10084                         }
 10085                     }
 10086                   else
 10087                     IT_RESET_X_ASCENT_DESCENT (it);
 10088 
 10089                   /* If the screen line ends with whitespace (or
 10090                      wrap-able character), and we are under word-wrap,
 10091                      don't use wrap_it: it is no longer relevant, but
 10092                      we won't have an opportunity to update it, since
 10093                      we are done with this screen line.  */
 10094                   if (may_wrap && IT_OVERFLOW_NEWLINE_INTO_FRINGE (it)
 10095                       /* If the character after the one which set the
 10096                          may_wrap flag says we can't wrap before it,
 10097                          we can't wrap here.  Therefore, wrap_it
 10098                          (previously found wrap-point) _is_ relevant
 10099                          in that case.  */
 10100                       && (!moved_forward || char_can_wrap_before (it)))
 10101                     {
 10102                       /* If we've found TO_X, go back there, as we now
 10103                          know the last word fits on this screen line.  */
 10104                       if ((op & MOVE_TO_X) && new_x == it->last_visible_x
 10105                           && atx_it.sp >= 0)
 10106                         {
 10107                           RESTORE_IT (it, &atx_it, atx_data);
 10108                           atpos_it.sp = -1;
 10109                           atx_it.sp = -1;
 10110                           result = MOVE_X_REACHED;
 10111                           break;
 10112                         }
 10113                     }
 10114                   else if (wrap_it.sp >= 0)
 10115                     {
 10116                       RESTORE_IT (it, &wrap_it, wrap_data);
 10117                       atpos_it.sp = -1;
 10118                       atx_it.sp = -1;
 10119                     }
 10120 
 10121                   move_trace ("move_it_in: continued at %td\n",
 10122                               IT_CHARPOS (*it));
 10123                   result = MOVE_LINE_CONTINUED;
 10124                   break;
 10125                 }
 10126 
 10127               if (BUFFER_POS_REACHED_P ())
 10128                 {
 10129                   if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
 10130                     goto buffer_pos_reached;
 10131                   if (it->line_wrap == WORD_WRAP && atpos_it.sp < 0)
 10132                     {
 10133                       SAVE_IT (atpos_it, *it, atpos_data);
 10134                       IT_RESET_X_ASCENT_DESCENT (&atpos_it);
 10135                     }
 10136                 }
 10137 
 10138               if (new_x > it->first_visible_x)
 10139                 {
 10140                   /* If we have reached the visible portion of the
 10141                      screen line, produce the line number if needed.  */
 10142                   if (line_number_pending)
 10143                     {
 10144                       line_number_pending = false;
 10145                       it->current_x = it->first_visible_x;
 10146                       maybe_produce_line_number (it);
 10147                       it->current_x += new_x - it->first_visible_x;
 10148                     }
 10149                   /* Glyph is visible.  Increment number of glyphs that
 10150                      would be displayed.  */
 10151                   ++it->hpos;
 10152                 }
 10153             }
 10154 
 10155           if (result != MOVE_UNDEFINED)
 10156             break;
 10157         }
 10158       else if (BUFFER_POS_REACHED_P ())
 10159         {
 10160         buffer_pos_reached:
 10161           IT_RESET_X_ASCENT_DESCENT (it);
 10162           result = MOVE_POS_MATCH_OR_ZV;
 10163           break;
 10164         }
 10165       else if ((op & MOVE_TO_X) && it->current_x >= to_x)
 10166         {
 10167           /* Stop when TO_X specified and reached.  This check is
 10168              necessary here because of lines consisting of a line end,
 10169              only.  The line end will not produce any glyphs and we
 10170              would never get MOVE_X_REACHED.  */
 10171           eassert (it->nglyphs == 0);
 10172           result = MOVE_X_REACHED;
 10173           break;
 10174         }
 10175 
 10176       /* Is this a line end?  If yes, we're done.  */
 10177       if (ITERATOR_AT_END_OF_LINE_P (it))
 10178         {
 10179           /* If we are past TO_CHARPOS, but never saw any character
 10180              positions smaller than TO_CHARPOS, return
 10181              MOVE_POS_MATCH_OR_ZV, like the unidirectional display
 10182              did.  */
 10183           if (it->bidi_p && (op & MOVE_TO_POS) != 0)
 10184             {
 10185               if (!saw_smaller_pos && IT_CHARPOS (*it) > to_charpos)
 10186                 {
 10187                   if (closest_pos < ZV)
 10188                     {
 10189                       RESTORE_IT (it, &ppos_it, ppos_data);
 10190                       /* Don't recurse if closest_pos is equal to
 10191                          to_charpos, since we have just tried that.  */
 10192                       if (closest_pos != to_charpos)
 10193                         move_it_in_display_line_to (it, closest_pos, -1,
 10194                                                     MOVE_TO_POS);
 10195                       result = MOVE_POS_MATCH_OR_ZV;
 10196                     }
 10197                   else
 10198                     goto buffer_pos_reached;
 10199                 }
 10200               else if (it->line_wrap == WORD_WRAP && atpos_it.sp >= 0
 10201                        && IT_CHARPOS (*it) > to_charpos)
 10202                 goto buffer_pos_reached;
 10203               else
 10204                 result = MOVE_NEWLINE_OR_CR;
 10205             }
 10206           else
 10207             result = MOVE_NEWLINE_OR_CR;
 10208           /* If lines are truncated, and the line we moved across is
 10209              completely hscrolled out of view, reset the line metrics
 10210              to those of the newline we've just processed, so that
 10211              glyphs not on display don't affect the line's height.  */
 10212           if (it->line_wrap == TRUNCATE
 10213               && it->current_x <= it->first_visible_x
 10214               && result == MOVE_NEWLINE_OR_CR
 10215               && it->char_to_display == '\n')
 10216             {
 10217               it->max_ascent = it->ascent;
 10218               it->max_descent = it->descent;
 10219             }
 10220           /* If we've processed the newline, make sure this flag is
 10221              reset, as it must only be set when the newline itself is
 10222              processed.  */
 10223           if (result == MOVE_NEWLINE_OR_CR)
 10224             it->constrain_row_ascent_descent_p = false;
 10225           break;
 10226         }
 10227 
 10228       prev_method = it->method;
 10229       if (it->method == GET_FROM_BUFFER)
 10230         prev_pos = IT_CHARPOS (*it);
 10231 
 10232       /* Detect overly-wide wrap-prefixes made of (space ...) display
 10233          properties.  When such a wrap prefix reaches past the right
 10234          margin of the window, we need to avoid the call to
 10235          set_iterator_to_next below, so that it->line_wrap is left at
 10236          its TRUNCATE value wisely set by handle_line_prefix.
 10237          Otherwise, set_iterator_to_next will pop the iterator stack,
 10238          restore it->line_wrap, and we might miss the opportunity to
 10239          exit the loop and return.  */
 10240       bool overwide_wrap_prefix =
 10241         CONSP (it->object) && EQ (XCAR (it->object), Qspace)
 10242         && it->sp > 0 && it->method == GET_FROM_STRETCH
 10243         && it->current_x >= it->last_visible_x
 10244         && it->continuation_lines_width > 0
 10245         && it->line_wrap == TRUNCATE && it->stack[0].line_wrap != TRUNCATE;
 10246       /* The current display element has been consumed.  Advance
 10247          to the next.  */
 10248       if (!overwide_wrap_prefix)
 10249         set_iterator_to_next (it, true);
 10250       if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
 10251         SET_TEXT_POS (this_line_min_pos, IT_CHARPOS (*it), IT_BYTEPOS (*it));
 10252       if (IT_CHARPOS (*it) < to_charpos)
 10253         saw_smaller_pos = true;
 10254       if (it->bidi_p
 10255           && (op & MOVE_TO_POS)
 10256           && IT_CHARPOS (*it) >= to_charpos
 10257           && IT_CHARPOS (*it) < closest_pos)
 10258         closest_pos = IT_CHARPOS (*it);
 10259 
 10260       /* Stop if lines are truncated and IT's current x-position is
 10261          past the right edge of the window now.  */
 10262       if (it->line_wrap == TRUNCATE
 10263           && it->current_x >= it->last_visible_x)
 10264         {
 10265           if (!FRAME_WINDOW_P (it->f)
 10266               || ((it->bidi_p && it->bidi_it.paragraph_dir == R2L)
 10267                   ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 10268                   : WINDOW_RIGHT_FRINGE_WIDTH (it->w)) == 0
 10269               || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 10270             {
 10271               bool at_eob_p = false;
 10272 
 10273               if ((at_eob_p = !get_next_display_element (it))
 10274                   || BUFFER_POS_REACHED_P ()
 10275                   /* If we are past TO_CHARPOS, but never saw any
 10276                      character positions smaller than TO_CHARPOS,
 10277                      return MOVE_POS_MATCH_OR_ZV, like the
 10278                      unidirectional display did.  */
 10279                   || (it->bidi_p && (op & MOVE_TO_POS) != 0
 10280                       && !saw_smaller_pos
 10281                       && IT_CHARPOS (*it) > to_charpos))
 10282                 {
 10283                   if (it->bidi_p
 10284                       && !BUFFER_POS_REACHED_P ()
 10285                       && !at_eob_p && closest_pos < ZV)
 10286                     {
 10287                       RESTORE_IT (it, &ppos_it, ppos_data);
 10288                       if (closest_pos != to_charpos)
 10289                         move_it_in_display_line_to (it, closest_pos, -1,
 10290                                                     MOVE_TO_POS);
 10291                     }
 10292                   result = MOVE_POS_MATCH_OR_ZV;
 10293                   break;
 10294                 }
 10295               if (ITERATOR_AT_END_OF_LINE_P (it))
 10296                 {
 10297                   result = MOVE_NEWLINE_OR_CR;
 10298                   break;
 10299                 }
 10300             }
 10301           else if (it->bidi_p && (op & MOVE_TO_POS) != 0
 10302                    && !saw_smaller_pos
 10303                    && IT_CHARPOS (*it) > to_charpos)
 10304             {
 10305               if (closest_pos < ZV)
 10306                 {
 10307                   RESTORE_IT (it, &ppos_it, ppos_data);
 10308                   if (closest_pos != to_charpos)
 10309                     move_it_in_display_line_to (it, closest_pos, -1,
 10310                                                 MOVE_TO_POS);
 10311                 }
 10312               result = MOVE_POS_MATCH_OR_ZV;
 10313               break;
 10314             }
 10315           result = MOVE_LINE_TRUNCATED;
 10316           break;
 10317         }
 10318 #undef IT_RESET_X_ASCENT_DESCENT
 10319     }
 10320 
 10321 #undef BUFFER_POS_REACHED_P
 10322 
 10323   /* If we scanned beyond TO_POS, restore the saved iterator either to
 10324      the wrap point (if found), or to atpos/atx location.  We decide which
 10325      data to use to restore the saved iterator state by their X coordinates,
 10326      since buffer positions might increase non-monotonically with screen
 10327      coordinates due to bidi reordering.  */
 10328   if (result == MOVE_LINE_CONTINUED
 10329       && it->line_wrap == WORD_WRAP
 10330       && wrap_it.sp >= 0
 10331       && ((atpos_it.sp >= 0 && wrap_it.current_x < atpos_it.current_x)
 10332           || (atx_it.sp >= 0 && wrap_it.current_x < atx_it.current_x)))
 10333     RESTORE_IT (it, &wrap_it, wrap_data);
 10334   else if (atpos_it.sp >= 0)
 10335     RESTORE_IT (it, &atpos_it, atpos_data);
 10336   else if (atx_it.sp >= 0)
 10337     RESTORE_IT (it, &atx_it, atx_data);
 10338 
 10339  done:
 10340 
 10341   if (atpos_data)
 10342     bidi_unshelve_cache (atpos_data, true);
 10343   if (atx_data)
 10344     bidi_unshelve_cache (atx_data, true);
 10345   if (wrap_data)
 10346     bidi_unshelve_cache (wrap_data, true);
 10347   if (ppos_data)
 10348     bidi_unshelve_cache (ppos_data, true);
 10349 
 10350   /* Restore the iterator settings altered at the beginning of this
 10351      function.  */
 10352   it->glyph_row = saved_glyph_row;
 10353   return result;
 10354 }
 10355 
 10356 /* For external use.  */
 10357 void
 10358 move_it_in_display_line (struct it *it,
 10359                          ptrdiff_t to_charpos, int to_x,
 10360                          enum move_operation_enum op)
 10361 {
 10362   if (it->line_wrap == WORD_WRAP
 10363       && (op & MOVE_TO_X))
 10364     {
 10365       struct it save_it;
 10366       void *save_data = NULL;
 10367       int skip;
 10368 
 10369       SAVE_IT (save_it, *it, save_data);
 10370       skip = move_it_in_display_line_to (it, to_charpos, to_x, op);
 10371       /* When word-wrap is on, TO_X may lie past the end
 10372          of a wrapped line.  Then it->current is the
 10373          character on the next line, so backtrack to the
 10374          space before the wrap point.  */
 10375       if (skip == MOVE_LINE_CONTINUED)
 10376         {
 10377           int prev_x = max (it->current_x - 1, 0);
 10378           RESTORE_IT (it, &save_it, save_data);
 10379           move_it_in_display_line_to
 10380             (it, -1, prev_x, MOVE_TO_X);
 10381         }
 10382       else
 10383         bidi_unshelve_cache (save_data, true);
 10384     }
 10385   else
 10386     move_it_in_display_line_to (it, to_charpos, to_x, op);
 10387 }
 10388 
 10389 
 10390 /* Move IT forward until it satisfies one or more of the criteria in
 10391    TO_CHARPOS, TO_X, TO_Y, and TO_VPOS.
 10392 
 10393    OP is a bit-mask that specifies where to stop, and in particular,
 10394    which of those four position arguments makes a difference.  See the
 10395    description of enum move_operation_enum.
 10396 
 10397    If TO_CHARPOS is in invisible text, e.g. a truncated part of a
 10398    screen line, this function will set IT to the next position that is
 10399    displayed to the right of TO_CHARPOS on the screen.
 10400 
 10401    Return the maximum pixel length of any line scanned but never more
 10402    than it.last_visible_x.  */
 10403 
 10404 int
 10405 move_it_to (struct it *it, ptrdiff_t to_charpos, int to_x, int to_y, int to_vpos, int op)
 10406 {
 10407   enum move_it_result skip, skip2 = MOVE_X_REACHED;
 10408   int line_height, line_start_x = 0, reached = 0;
 10409   int max_current_x = 0;
 10410   void *backup_data = NULL;
 10411   ptrdiff_t orig_charpos = -1;
 10412   enum it_method orig_method = NUM_IT_METHODS;
 10413 
 10414   for (;;)
 10415     {
 10416       orig_charpos = IT_CHARPOS (*it);
 10417       orig_method = it->method;
 10418       if (op & MOVE_TO_VPOS)
 10419         {
 10420           /* If no TO_CHARPOS and no TO_X specified, stop at the
 10421              start of the line TO_VPOS.  */
 10422           if ((op & (MOVE_TO_X | MOVE_TO_POS)) == 0)
 10423             {
 10424               if (it->vpos == to_vpos)
 10425                 {
 10426                   reached = 1;
 10427                   break;
 10428                 }
 10429               else
 10430                 skip = move_it_in_display_line_to (it, -1, -1, 0);
 10431             }
 10432           else
 10433             {
 10434               /* TO_VPOS >= 0 means stop at TO_X in the line at
 10435                  TO_VPOS, or at TO_POS, whichever comes first.  */
 10436               if (it->vpos == to_vpos)
 10437                 {
 10438                   reached = 2;
 10439                   break;
 10440                 }
 10441 
 10442               skip = move_it_in_display_line_to (it, to_charpos, to_x, op);
 10443 
 10444               if (skip == MOVE_POS_MATCH_OR_ZV || it->vpos == to_vpos)
 10445                 {
 10446                   reached = 3;
 10447                   break;
 10448                 }
 10449               else if (skip == MOVE_X_REACHED && it->vpos != to_vpos)
 10450                 {
 10451                   /* We have reached TO_X but not in the line we want.  */
 10452                   skip = move_it_in_display_line_to (it, to_charpos,
 10453                                                      -1, MOVE_TO_POS);
 10454                   if (skip == MOVE_POS_MATCH_OR_ZV)
 10455                     {
 10456                       reached = 4;
 10457                       break;
 10458                     }
 10459                 }
 10460             }
 10461         }
 10462       else if (op & MOVE_TO_Y)
 10463         {
 10464           struct it it_backup;
 10465 
 10466           if (it->line_wrap == WORD_WRAP)
 10467             SAVE_IT (it_backup, *it, backup_data);
 10468 
 10469           /* TO_Y specified means stop at TO_X in the line containing
 10470              TO_Y---or at TO_CHARPOS if this is reached first.  The
 10471              problem is that we can't really tell whether the line
 10472              contains TO_Y before we have completely scanned it, and
 10473              this may skip past TO_X.  What we do is to first scan to
 10474              TO_X.
 10475 
 10476              If TO_X is not specified, use a TO_X of zero.  The reason
 10477              is to make the outcome of this function more predictable.
 10478              If we didn't use TO_X == 0, we would stop at the end of
 10479              the line which is probably not what a caller would expect
 10480              to happen.  */
 10481           skip = move_it_in_display_line_to
 10482             (it, to_charpos, ((op & MOVE_TO_X) ? to_x : 0),
 10483              (MOVE_TO_X | (op & MOVE_TO_POS)));
 10484 
 10485           /* If TO_CHARPOS is reached or ZV, we don't have to do more.  */
 10486           if (skip == MOVE_POS_MATCH_OR_ZV)
 10487             reached = 5;
 10488           else if (skip == MOVE_X_REACHED)
 10489             {
 10490               /* If TO_X was reached, we want to know whether TO_Y is
 10491                  in the line.  We know this is the case if the already
 10492                  scanned glyphs make the line tall enough.  Otherwise,
 10493                  we must check by scanning the rest of the line.  */
 10494               line_height = it->max_ascent + it->max_descent;
 10495               if (to_y >= it->current_y
 10496                   && to_y < it->current_y + line_height)
 10497                 {
 10498                   reached = 6;
 10499                   break;
 10500                 }
 10501               SAVE_IT (it_backup, *it, backup_data);
 10502               move_trace ("move_it: from %td\n", IT_CHARPOS (*it));
 10503               skip2 = move_it_in_display_line_to (it, to_charpos, -1,
 10504                                                   op & MOVE_TO_POS);
 10505               move_trace ("move_it: to %td\n", IT_CHARPOS (*it));
 10506               line_height = it->max_ascent + it->max_descent;
 10507               move_trace ("move_it: line_height = %d\n", line_height);
 10508 
 10509               if (to_y >= it->current_y
 10510                   && to_y < it->current_y + line_height)
 10511                 {
 10512                   /* If TO_Y is in this line and TO_X was reached
 10513                      above, we scanned too far.  We have to restore
 10514                      IT's settings to the ones before skipping.  But
 10515                      keep the more accurate values of max_ascent and
 10516                      max_descent we've found while skipping the rest
 10517                      of the line, for the sake of callers, such as
 10518                      pos_visible_p, that need to know the line
 10519                      height.  */
 10520                   int max_ascent = it->max_ascent;
 10521                   int max_descent = it->max_descent;
 10522 
 10523                   RESTORE_IT (it, &it_backup, backup_data);
 10524                   it->max_ascent = max_ascent;
 10525                   it->max_descent = max_descent;
 10526                   reached = 6;
 10527                 }
 10528               else
 10529                 {
 10530                   skip = skip2;
 10531                   if (skip == MOVE_POS_MATCH_OR_ZV)
 10532                     {
 10533                       reached = 7;
 10534                       /* If the last move_it_in_display_line_to call
 10535                          took us away from TO_CHARPOS, back up to the
 10536                          previous position, as it is a better
 10537                          approximation of TO_CHARPOS.  (Note that we
 10538                          could have both positions after TO_CHARPOS or
 10539                          both positions before it, due to bidi
 10540                          reordering.)  */
 10541                       if (to_charpos > 0
 10542                           && IT_CHARPOS (*it) != to_charpos
 10543                           && ((IT_CHARPOS (it_backup) > to_charpos)
 10544                               == (IT_CHARPOS (*it) > to_charpos)))
 10545                         {
 10546                           int max_ascent = it->max_ascent;
 10547                           int max_descent = it->max_descent;
 10548 
 10549                           RESTORE_IT (it, &it_backup, backup_data);
 10550                           it->max_ascent = max_ascent;
 10551                           it->max_descent = max_descent;
 10552                         }
 10553                     }
 10554                 }
 10555             }
 10556           else
 10557             {
 10558               /* Check whether TO_Y is in this line.  */
 10559               line_height = it->max_ascent + it->max_descent;
 10560               move_trace ("move_it: line_height = %d\n", line_height);
 10561 
 10562               if (to_y >= it->current_y
 10563                   && to_y < it->current_y + line_height)
 10564                 {
 10565                   if (to_y > it->current_y)
 10566                     max_current_x = max (it->current_x, max_current_x);
 10567 
 10568                   /* When word-wrap is on, TO_X may lie past the end
 10569                      of a wrapped line.  Then it->current is the
 10570                      character on the next line, so backtrack to the
 10571                      space before the wrap point.  */
 10572                   if (skip == MOVE_LINE_CONTINUED
 10573                       && it->line_wrap == WORD_WRAP)
 10574                     {
 10575                       int prev_x = max (it->current_x - 1, 0);
 10576                       RESTORE_IT (it, &it_backup, backup_data);
 10577                       skip = move_it_in_display_line_to
 10578                         (it, -1, prev_x, MOVE_TO_X);
 10579                     }
 10580 
 10581                   reached = 6;
 10582                 }
 10583             }
 10584 
 10585           if (reached)
 10586             {
 10587               max_current_x = max (it->current_x, max_current_x);
 10588               break;
 10589             }
 10590         }
 10591       else if (BUFFERP (it->object)
 10592                && (it->method == GET_FROM_BUFFER
 10593                    || it->method == GET_FROM_STRETCH)
 10594                && IT_CHARPOS (*it) >= to_charpos
 10595                /* Under bidi iteration, a call to set_iterator_to_next
 10596                   can scan far beyond to_charpos if the initial
 10597                   portion of the next line needs to be reordered.  In
 10598                   that case, give move_it_in_display_line_to another
 10599                   chance below.  */
 10600                && !(it->bidi_p
 10601                     && it->bidi_it.scan_dir == -1))
 10602         skip = MOVE_POS_MATCH_OR_ZV;
 10603       else
 10604         skip = move_it_in_display_line_to (it, to_charpos, -1, MOVE_TO_POS);
 10605 
 10606       switch (skip)
 10607         {
 10608         case MOVE_POS_MATCH_OR_ZV:
 10609           max_current_x = max (it->current_x, max_current_x);
 10610           reached = 8;
 10611           goto out;
 10612 
 10613         case MOVE_NEWLINE_OR_CR:
 10614           max_current_x = max (it->current_x, max_current_x);
 10615           if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 10616             it->override_ascent = -1;
 10617           set_iterator_to_next (it, true);
 10618           it->continuation_lines_width = 0;
 10619           break;
 10620 
 10621         case MOVE_LINE_TRUNCATED:
 10622           max_current_x = it->last_visible_x;
 10623           it->continuation_lines_width = 0;
 10624           reseat_at_next_visible_line_start (it, false);
 10625           if ((op & MOVE_TO_POS) != 0
 10626               && (IT_CHARPOS (*it) > to_charpos
 10627                   || (IT_CHARPOS (*it) == to_charpos
 10628                       /* Consider TO_CHARPOS as REACHED if we are at
 10629                          EOB that ends in something other than a newline.  */
 10630                       && to_charpos == ZV
 10631                       && (ZV_BYTE <= 1 || FETCH_BYTE (ZV_BYTE - 1) != '\n')
 10632                       /* But if we have a display or an overlay string
 10633                          at EOB, keep going until we exhaust all the
 10634                          characters of the string(s).  */
 10635                       && (it->sp == 0
 10636                           || (STRINGP (it->string)
 10637                               && (it->current.overlay_string_index < 0
 10638                                   || (it->current.overlay_string_index >= 0
 10639                                       && it->current.overlay_string_index
 10640                                          >= it->n_overlay_strings - 1))
 10641                               && IT_STRING_CHARPOS (*it) >= it->end_charpos)))))
 10642             {
 10643               reached = 9;
 10644               goto out;
 10645             }
 10646           break;
 10647 
 10648         case MOVE_LINE_CONTINUED:
 10649           max_current_x = it->last_visible_x;
 10650           /* For continued lines ending in a tab, some of the glyphs
 10651              associated with the tab are displayed on the current
 10652              line.  Since it->current_x does not include these glyphs,
 10653              we use it->last_visible_x instead.  */
 10654           if (it->c == '\t')
 10655             {
 10656               it->continuation_lines_width += it->last_visible_x;
 10657               /* When moving by vpos, ensure that the iterator really
 10658                  advances to the next line (bug#847, bug#969).  Fixme:
 10659                  do we need to do this in other circumstances?  */
 10660               if (it->current_x != it->last_visible_x
 10661                   && (op & MOVE_TO_VPOS)
 10662                   && !(op & (MOVE_TO_X | MOVE_TO_POS)))
 10663                 {
 10664                   line_start_x = it->current_x + it->pixel_width
 10665                     - it->last_visible_x;
 10666                   if (FRAME_WINDOW_P (it->f))
 10667                     {
 10668                       struct face *face = FACE_FROM_ID (it->f, it->face_id);
 10669                       struct font *face_font = face->font;
 10670 
 10671                       /* When display_line produces a continued line
 10672                          that ends in a TAB, it skips a tab stop that
 10673                          is closer than the font's space character
 10674                          width (see gui_produce_glyphs where it produces
 10675                          the stretch glyph which represents a TAB).
 10676                          We need to reproduce the same logic here.  */
 10677                       eassert (face_font);
 10678                       if (face_font)
 10679                         {
 10680                           if (line_start_x < face_font->space_width)
 10681                             line_start_x
 10682                               += it->tab_width * face_font->space_width;
 10683                         }
 10684                     }
 10685                   set_iterator_to_next (it, false);
 10686                 }
 10687             }
 10688           else
 10689             {
 10690               /* Make sure we do advance, otherwise we might infloop.
 10691                  This could happen when the first display element is
 10692                  wider than the window, or if we have a wrap-prefix
 10693                  that doesn't leave enough space after it to display
 10694                  even a single character.  We only do this for moving
 10695                  through buffer text, as with display/overlay strings
 10696                  we'd need to also compare it->object's, and this is
 10697                  unlikely to happen in that case anyway.  */
 10698               if (IT_CHARPOS (*it) == orig_charpos
 10699                   && it->method == orig_method
 10700                   && orig_method == GET_FROM_BUFFER)
 10701                 set_iterator_to_next (it, false);
 10702               it->continuation_lines_width += it->current_x;
 10703             }
 10704           break;
 10705 
 10706         default:
 10707           emacs_abort ();
 10708         }
 10709 
 10710       /* Reset/increment for the next run.  */
 10711       it->current_x = line_start_x;
 10712       line_start_x = 0;
 10713       it->hpos = 0;
 10714       it->line_number_produced_p = false;
 10715       it->current_y += it->max_ascent + it->max_descent;
 10716       ++it->vpos;
 10717       last_height = it->max_ascent + it->max_descent;
 10718       it->max_ascent = it->max_descent = 0;
 10719     }
 10720 
 10721  out:
 10722 
 10723   /* On text terminals, we may stop at the end of a line in the middle
 10724      of a multi-character glyph.  If the glyph itself is continued,
 10725      i.e. it is actually displayed on the next line, don't treat this
 10726      stopping point as valid; move to the next line instead (unless
 10727      that brings us offscreen).  */
 10728   if (!FRAME_WINDOW_P (it->f)
 10729       && op & MOVE_TO_POS
 10730       && IT_CHARPOS (*it) == to_charpos
 10731       && it->what == IT_CHARACTER
 10732       && it->nglyphs > 1
 10733       && it->line_wrap == WINDOW_WRAP
 10734       && it->current_x == it->last_visible_x - 1
 10735       && it->c != '\n'
 10736       && it->c != '\t'
 10737       && it->w->window_end_valid
 10738       && it->vpos < it->w->window_end_vpos)
 10739     {
 10740       it->continuation_lines_width += it->current_x;
 10741       it->current_x = it->hpos = it->max_ascent = it->max_descent = 0;
 10742       it->current_y += it->max_ascent + it->max_descent;
 10743       ++it->vpos;
 10744       last_height = it->max_ascent + it->max_descent;
 10745     }
 10746 
 10747   if (backup_data)
 10748     bidi_unshelve_cache (backup_data, true);
 10749 
 10750   move_trace ("move_it_to: reached %d\n", reached);
 10751 
 10752   return max_current_x;
 10753 }
 10754 
 10755 
 10756 /* Move iterator IT backward by a specified y-distance DY, DY >= 0.
 10757 
 10758    If DY > 0, move IT backward that many pixels.
 10759    DY = 0 means move IT backward to the preceding line start or to BEGV.
 10760    This function may move over less or more than DY pixels if
 10761    IT->current_y - DY ends up in the middle of a line; in this case
 10762    IT->current_y will be set to the top of the line either before or
 10763    after the exact pixel coordinate.  */
 10764 
 10765 void
 10766 move_it_vertically_backward (struct it *it, int dy)
 10767 {
 10768   int nlines, h;
 10769   struct it it2, it3;
 10770   void *it2data = NULL, *it3data = NULL;
 10771   ptrdiff_t start_pos;
 10772   int nchars_per_row
 10773     = (it->last_visible_x - it->first_visible_x) / FRAME_COLUMN_WIDTH (it->f);
 10774   ptrdiff_t pos_limit;
 10775 
 10776  move_further_back:
 10777   eassert (dy >= 0);
 10778 
 10779   start_pos = IT_CHARPOS (*it);
 10780 
 10781   /* Estimate how many newlines we must move back.  */
 10782   nlines = max (1, dy / default_line_pixel_height (it->w));
 10783   if (it->line_wrap == TRUNCATE || nchars_per_row == 0)
 10784     pos_limit = BEGV;
 10785   else
 10786     pos_limit = max (start_pos - nlines * nchars_per_row, BEGV);
 10787 
 10788   /* Set the iterator's position that many lines back.  But don't go
 10789      back more than NLINES full screen lines -- this wins a day with
 10790      buffers which have very long lines.  */
 10791   while (nlines-- && IT_CHARPOS (*it) > pos_limit)
 10792     back_to_previous_visible_line_start (it);
 10793 
 10794   /* Reseat the iterator here.  When moving backward, we don't want
 10795      reseat to skip forward over invisible text, set up the iterator
 10796      to deliver from overlay strings at the new position etc.  So,
 10797      use reseat_1 here.  */
 10798   reseat_1 (it, it->current.pos, true);
 10799 
 10800   /* We are now surely at a line start.  */
 10801   it->current_x = it->hpos = 0; /* FIXME: this is incorrect when bidi
 10802                                    reordering is in effect.  */
 10803   it->continuation_lines_width = 0;
 10804 
 10805   /* Move forward and see what y-distance we moved.  First move to the
 10806      start of the next line so that we get its height.  We need this
 10807      height to be able to tell whether we reached the specified
 10808      y-distance.  */
 10809   SAVE_IT (it2, *it, it2data);
 10810   it2.max_ascent = it2.max_descent = 0;
 10811   do
 10812     {
 10813       move_it_to (&it2, start_pos, -1, -1, it2.vpos + 1,
 10814                   MOVE_TO_POS | MOVE_TO_VPOS);
 10815     }
 10816   while (!(IT_POS_VALID_AFTER_MOVE_P (&it2)
 10817            /* If we are in a display string which starts at START_POS,
 10818               and that display string includes a newline, and we are
 10819               right after that newline (i.e. at the beginning of a
 10820               display line), exit the loop, because otherwise we will
 10821               infloop, since move_it_to will see that it is already at
 10822               START_POS and will not move.  */
 10823            || (it2.method == GET_FROM_STRING
 10824                && IT_CHARPOS (it2) == start_pos
 10825                && SREF (it2.string, IT_STRING_BYTEPOS (it2) - 1) == '\n')));
 10826   eassert (IT_CHARPOS (*it) >= BEGV);
 10827   SAVE_IT (it3, it2, it3data);
 10828 
 10829   move_it_to (&it2, start_pos, -1, -1, -1, MOVE_TO_POS);
 10830   eassert (IT_CHARPOS (*it) >= BEGV);
 10831   /* H is the actual vertical distance from the position in *IT
 10832      and the starting position.  */
 10833   h = it2.current_y - it->current_y;
 10834   /* NLINES is the distance in number of lines.  */
 10835   nlines = it2.vpos - it->vpos;
 10836 
 10837   /* Correct IT's y and vpos position
 10838      so that they are relative to the starting point.  */
 10839   it->vpos -= nlines;
 10840   it->current_y -= h;
 10841 
 10842   if (dy == 0)
 10843     {
 10844       /* DY == 0 means move to the start of the screen line.  The
 10845          value of nlines is > 0 if continuation lines were involved,
 10846          or if the original IT position was at start of a line.  */
 10847       RESTORE_IT (it, it, it2data);
 10848       if (nlines > 0)
 10849         move_it_by_lines (it, nlines);
 10850       /* The above code moves us to some position NLINES down,
 10851          usually to its first glyph (leftmost in an L2R line), but
 10852          that's not necessarily the start of the line, under bidi
 10853          reordering.  We want to get to the character position
 10854          that is immediately after the newline of the previous
 10855          line.  */
 10856       if (it->bidi_p
 10857           && !it->continuation_lines_width
 10858           && !STRINGP (it->string)
 10859           && IT_CHARPOS (*it) > BEGV
 10860           && FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n')
 10861         {
 10862           ptrdiff_t cp = IT_CHARPOS (*it), bp = IT_BYTEPOS (*it);
 10863 
 10864           dec_both (&cp, &bp);
 10865           SET_WITH_NARROWED_BEGV (it, cp,
 10866                                   find_newline_no_quit (cp, bp, -1, NULL),
 10867                                   get_small_narrowing_begv (it->w, IT_CHARPOS (*it)));
 10868           move_it_to (it, cp, -1, -1, -1, MOVE_TO_POS);
 10869         }
 10870       bidi_unshelve_cache (it3data, true);
 10871     }
 10872   else
 10873     {
 10874       /* The y-position we try to reach, relative to *IT.
 10875          Note that H has been subtracted in front of the if-statement.  */
 10876       int target_y = it->current_y + h - dy;
 10877       int y0 = it3.current_y;
 10878       int y1;
 10879       int line_height;
 10880 
 10881       RESTORE_IT (&it3, &it3, it3data);
 10882       y1 = line_bottom_y (&it3);
 10883       line_height = y1 - y0;
 10884       RESTORE_IT (it, it, it2data);
 10885       /* If we did not reach target_y, try to move further backward if
 10886          we can.  If we moved too far backward, try to move forward.  */
 10887       if (target_y < it->current_y
 10888           /* This is heuristic.  In a window that's 3 lines high, with
 10889              a line height of 13 pixels each, recentering with point
 10890              on the bottom line will try to move -39/2 = 19 pixels
 10891              backward.  Try to avoid moving into the first line.  */
 10892           && (it->current_y - target_y
 10893               > min (window_box_height (it->w), line_height * 2 / 3))
 10894           && IT_CHARPOS (*it) > BEGV)
 10895         {
 10896           move_trace ("  not far enough -> move_vert %d\n",
 10897                       target_y - it->current_y);
 10898           dy = it->current_y - target_y;
 10899           goto move_further_back;
 10900         }
 10901       else if (target_y >= it->current_y + line_height
 10902                && IT_CHARPOS (*it) < ZV)
 10903         {
 10904           /* Should move forward by at least one line, maybe more.
 10905 
 10906              Note: Calling move_it_by_lines can be expensive on
 10907              terminal frames, where compute_motion is used (via
 10908              vmotion) to do the job, when there are very long lines
 10909              and truncate-lines is nil.  That's the reason for
 10910              treating terminal frames specially here.  */
 10911 
 10912           if (!FRAME_WINDOW_P (it->f))
 10913             move_it_vertically (it, target_y - it->current_y);
 10914           else
 10915             {
 10916               struct text_pos last_pos;
 10917               int last_y, last_vpos;
 10918               do
 10919                 {
 10920                   last_pos = it->current.pos;
 10921                   last_y = it->current_y;
 10922                   last_vpos = it->vpos;
 10923                   move_it_by_lines (it, 1);
 10924                 }
 10925               while (target_y > it->current_y && IT_CHARPOS (*it) < ZV);
 10926               if (it->current_y > target_y)
 10927                 {
 10928                   reseat (it, last_pos, true);
 10929                   it->current_y = last_y;
 10930                   it->vpos = last_vpos;
 10931                 }
 10932             }
 10933         }
 10934     }
 10935 }
 10936 
 10937 
 10938 /* Move IT by a specified amount of pixel lines DY.  DY negative means
 10939    move backwards.  DY = 0 means move to start of screen line.  At the
 10940    end, IT will be on the start of a screen line.  */
 10941 
 10942 void
 10943 move_it_vertically (struct it *it, int dy)
 10944 {
 10945   if (dy <= 0)
 10946     move_it_vertically_backward (it, -dy);
 10947   else
 10948     {
 10949       move_trace ("move_it_v: from %td, %d\n", IT_CHARPOS (*it), dy);
 10950       move_it_to (it, ZV, -1, it->current_y + dy, -1,
 10951                   MOVE_TO_POS | MOVE_TO_Y);
 10952       move_trace ("move_it_v: to %td\n", IT_CHARPOS (*it));
 10953 
 10954       /* If buffer ends in ZV without a newline, move to the start of
 10955          the line to satisfy the post-condition.  */
 10956       if (IT_CHARPOS (*it) == ZV
 10957           && ZV > BEGV
 10958           && FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n')
 10959         move_it_by_lines (it, 0);
 10960     }
 10961 }
 10962 
 10963 
 10964 /* Move iterator IT past the end of the text line it is in.  */
 10965 
 10966 void
 10967 move_it_past_eol (struct it *it)
 10968 {
 10969   enum move_it_result rc;
 10970 
 10971   rc = move_it_in_display_line_to (it, Z, 0, MOVE_TO_POS);
 10972   if (rc == MOVE_NEWLINE_OR_CR)
 10973     set_iterator_to_next (it, false);
 10974 }
 10975 
 10976 
 10977 /* Move IT by a specified number DVPOS of screen lines down.  DVPOS
 10978    negative means move up.  DVPOS == 0 means move to the start of the
 10979    screen line.
 10980 
 10981    Optimization idea: If we would know that IT->f doesn't use
 10982    a face with proportional font, we could be faster for
 10983    truncate-lines nil.  */
 10984 
 10985 void
 10986 move_it_by_lines (struct it *it, ptrdiff_t dvpos)
 10987 {
 10988 
 10989   /* The commented-out optimization uses vmotion on terminals.  This
 10990      gives bad results, because elements like it->what, on which
 10991      callers such as pos_visible_p rely, aren't updated.  */
 10992   /* struct position pos;
 10993     if (!FRAME_WINDOW_P (it->f))
 10994     {
 10995       struct text_pos textpos;
 10996 
 10997       pos = *vmotion (IT_CHARPOS (*it), dvpos, it->w);
 10998       SET_TEXT_POS (textpos, pos.bufpos, pos.bytepos);
 10999       reseat (it, textpos, true);
 11000       it->vpos += pos.vpos;
 11001       it->current_y += pos.vpos;
 11002     }
 11003     else */
 11004 
 11005   if (dvpos == 0)
 11006     {
 11007       /* DVPOS == 0 means move to the start of the screen line.  */
 11008       move_it_vertically_backward (it, 0);
 11009       /* Let next call to line_bottom_y calculate real line height.  */
 11010       last_height = 0;
 11011     }
 11012   else if (dvpos > 0)
 11013     {
 11014       move_it_to (it, -1, -1, -1, it->vpos + dvpos, MOVE_TO_VPOS);
 11015       if (!IT_POS_VALID_AFTER_MOVE_P (it))
 11016         {
 11017           /* Only move to the next buffer position if we ended up in a
 11018              string from display property, not in an overlay string
 11019              (before-string or after-string).  That is because the
 11020              latter don't conceal the underlying buffer position, so
 11021              we can ask to move the iterator to the exact position we
 11022              are interested in.  Note that, even if we are already at
 11023              IT_CHARPOS (*it), the call below is not a no-op, as it
 11024              will detect that we are at the end of the string, pop the
 11025              iterator, and compute it->current_x and it->hpos
 11026              correctly.  */
 11027           move_it_to (it, IT_CHARPOS (*it) + it->string_from_display_prop_p,
 11028                       -1, -1, -1, MOVE_TO_POS);
 11029         }
 11030     }
 11031   else
 11032     {
 11033       struct it it2;
 11034       void *it2data = NULL;
 11035       ptrdiff_t start_charpos, orig_charpos, i;
 11036       int nchars_per_row
 11037         = (it->last_visible_x - it->first_visible_x) / FRAME_COLUMN_WIDTH (it->f);
 11038       bool hit_pos_limit = false;
 11039       ptrdiff_t pos_limit;
 11040 
 11041       /* Start at the beginning of the screen line containing IT's
 11042          position.  This may actually move vertically backwards,
 11043          in case of overlays, so adjust dvpos accordingly.  */
 11044       dvpos += it->vpos;
 11045       orig_charpos = IT_CHARPOS (*it);
 11046       move_it_vertically_backward (it, 0);
 11047       dvpos -= it->vpos;
 11048 
 11049       /* Go back -DVPOS buffer lines, but no farther than -DVPOS full
 11050          screen lines, and reseat the iterator there.  */
 11051       start_charpos = IT_CHARPOS (*it);
 11052       if (it->line_wrap == TRUNCATE || nchars_per_row == 0)
 11053         pos_limit = BEGV;
 11054       else
 11055         pos_limit = max (start_charpos + dvpos * nchars_per_row, BEGV);
 11056 
 11057       for (i = -dvpos; i > 0 && IT_CHARPOS (*it) > pos_limit; --i)
 11058         back_to_previous_visible_line_start (it);
 11059       if (i > 0 && IT_CHARPOS (*it) <= pos_limit)
 11060         hit_pos_limit = true;
 11061       reseat (it, it->current.pos, true);
 11062 
 11063       /* Move further back if we end up in a string or an image.  */
 11064       while (!IT_POS_VALID_AFTER_MOVE_P (it))
 11065         {
 11066           /* First try to move to start of display line.  */
 11067           dvpos += it->vpos;
 11068           move_it_vertically_backward (it, 0);
 11069           dvpos -= it->vpos;
 11070           if (IT_POS_VALID_AFTER_MOVE_P (it))
 11071             break;
 11072           /* If start of line is still in string or image,
 11073              move further back.  */
 11074           back_to_previous_visible_line_start (it);
 11075           reseat (it, it->current.pos, true);
 11076           dvpos--;
 11077         }
 11078 
 11079       it->current_x = it->hpos = 0;
 11080 
 11081       /* Above call may have moved too far if continuation lines
 11082          are involved.  Scan forward and see if it did.  */
 11083       SAVE_IT (it2, *it, it2data);
 11084       it2.vpos = it2.current_y = 0;
 11085       move_it_to (&it2, start_charpos, -1, -1, -1, MOVE_TO_POS);
 11086       it->vpos -= it2.vpos;
 11087       it->current_y -= it2.current_y;
 11088       it->current_x = it->hpos = 0;
 11089 
 11090       /* If we moved too far back, move IT some lines forward.  */
 11091       if (it2.vpos > -dvpos)
 11092         {
 11093           int delta = it2.vpos + dvpos;
 11094 
 11095           RESTORE_IT (&it2, &it2, it2data);
 11096           SAVE_IT (it2, *it, it2data);
 11097           move_it_to (it, -1, -1, -1, it->vpos + delta, MOVE_TO_VPOS);
 11098           /* Move back again if we got too far ahead,
 11099              or didn't move at all.  */
 11100           if (it->vpos - it2.vpos > delta || IT_CHARPOS (*it) == orig_charpos)
 11101             RESTORE_IT (it, &it2, it2data);
 11102           else
 11103             bidi_unshelve_cache (it2data, true);
 11104         }
 11105       else if (hit_pos_limit && pos_limit > BEGV
 11106                && dvpos < 0 && it2.vpos < -dvpos)
 11107         {
 11108           /* If we hit the limit, but still didn't make it far enough
 11109              back, that means there's a display string with a newline
 11110              covering a large chunk of text, and that caused
 11111              back_to_previous_visible_line_start try to go too far.
 11112              Punish those who commit such atrocities by going back
 11113              until we've reached DVPOS, after lifting the limit, which
 11114              could make it slow for very long lines.  "If it hurts,
 11115              don't do that!"  */
 11116           dvpos += it2.vpos;
 11117           RESTORE_IT (it, it, it2data);
 11118           for (i = -dvpos; i > 0; --i)
 11119             {
 11120               back_to_previous_visible_line_start (it);
 11121               it->vpos--;
 11122             }
 11123           reseat_1 (it, it->current.pos, true);
 11124         }
 11125       else
 11126         RESTORE_IT (it, it, it2data);
 11127     }
 11128 }
 11129 
 11130 int
 11131 partial_line_height (struct it *it_origin)
 11132 {
 11133   /* In a buffer with very long and truncated lines, we ignore the
 11134      possibly-partial height of the last line in the window: it is too
 11135      expensive to compute that (since in most cases that involves
 11136      going all the way to ZV), and the effect of ignoring it is
 11137      relatively minor.  */
 11138   if (XBUFFER (it_origin->w->contents)->long_line_optimizations_p
 11139       && it_origin->line_wrap == TRUNCATE)
 11140     return 0;
 11141 
 11142   int partial_height;
 11143   void *it_data = NULL;
 11144   struct it it;
 11145   SAVE_IT (it, *it_origin, it_data);
 11146   move_it_to (&it, ZV, -1, it.last_visible_y, -1,
 11147               MOVE_TO_POS | MOVE_TO_Y);
 11148   if (it.what == IT_EOB)
 11149     {
 11150       int vis_height = it.last_visible_y - it.current_y;
 11151       int height = it.ascent + it.descent;
 11152       partial_height = (vis_height < height) ? vis_height : 0;
 11153     }
 11154   else
 11155     {
 11156       int last_line_y = it.current_y;
 11157       move_it_by_lines (&it, 1);
 11158       partial_height = (it.current_y > it.last_visible_y)
 11159         ? it.last_visible_y - last_line_y : 0;
 11160     }
 11161   RESTORE_IT (&it, &it, it_data);
 11162   return partial_height;
 11163 }
 11164 
 11165 /* Approximate move_it_in_display_line_to for very long and truncated
 11166    display lines, when moving horizontally.  This is used when the
 11167    buffer's long_line_optimizations_p flag is set.  It ignores various
 11168    complications, like different font sizes, invisible text, display
 11169    and overlay strings, and, to some degree, bidirectional text.  So
 11170    caveat emptor!
 11171 
 11172    Starting from IT's position, reseat IT after skipping NCHARS
 11173    characters or to the next newline/ZV, whichever comes first.  Return
 11174    what move_it_in_display_line_to would have returned in this case.  */
 11175 
 11176 static enum move_it_result
 11177 fast_move_it_horizontally (struct it *it, ptrdiff_t nchars)
 11178 {
 11179   ptrdiff_t nl_bytepos;
 11180   ptrdiff_t nl_pos = find_newline_no_quit (IT_CHARPOS (*it), IT_BYTEPOS (*it),
 11181                                            1, &nl_bytepos);
 11182   struct text_pos new_pos;
 11183   enum move_it_result move_result;
 11184 
 11185   if (nl_pos - IT_CHARPOS (*it) > nchars)
 11186     {
 11187       SET_TEXT_POS (new_pos,
 11188                     IT_CHARPOS (*it) + nchars,
 11189                     CHAR_TO_BYTE (IT_CHARPOS (*it) + nchars));
 11190       move_result = MOVE_X_REACHED;
 11191     }
 11192   else
 11193     {
 11194       if (nl_bytepos < ZV_BYTE
 11195           || (nl_bytepos > BEGV_BYTE
 11196               && FETCH_BYTE (nl_bytepos - 1) == '\n'))
 11197         {
 11198           nl_pos--;
 11199           nl_bytepos--;
 11200           move_result = MOVE_NEWLINE_OR_CR;
 11201         }
 11202       else
 11203         move_result = MOVE_POS_MATCH_OR_ZV;
 11204       SET_TEXT_POS (new_pos, nl_pos, nl_bytepos);
 11205     }
 11206   reseat (it, new_pos, false);
 11207   return move_result;
 11208 }
 11209 
 11210 /* Return true if IT points into the middle of a display vector.  */
 11211 
 11212 bool
 11213 in_display_vector_p (struct it *it)
 11214 {
 11215   return (it->method == GET_FROM_DISPLAY_VECTOR
 11216           && it->current.dpvec_index > 0
 11217           && it->dpvec + it->current.dpvec_index != it->dpend);
 11218 }
 11219 
 11220 /* This is like Fwindow_text_pixel_size but assumes that WINDOW's buffer
 11221    is the current buffer.  Fbuffer_text_pixel_size calls it after it has
 11222    set WINDOW's buffer to the buffer specified by its BUFFER_OR_NAME
 11223    argument.  */
 11224 static Lisp_Object
 11225 window_text_pixel_size (Lisp_Object window, Lisp_Object from, Lisp_Object to,
 11226                         Lisp_Object x_limit, Lisp_Object y_limit,
 11227                         Lisp_Object mode_lines, Lisp_Object ignore_line_at_end)
 11228 {
 11229   struct window *w = decode_live_window (window);
 11230   struct it it;
 11231   ptrdiff_t start, end, bpos;
 11232   struct text_pos startp;
 11233   void *itdata = NULL;
 11234   int c, max_x = 0, max_y = 0, x = 0, y = 0, vertical_offset = 0, doff = 0;
 11235 
 11236   if (NILP (from))
 11237     {
 11238       start = BEGV;
 11239       bpos = BEGV_BYTE;
 11240     }
 11241   else if (EQ (from, Qt))
 11242     {
 11243       start = BEGV;
 11244       bpos = BEGV_BYTE;
 11245       while (bpos < ZV_BYTE)
 11246         {
 11247           c = FETCH_BYTE (bpos);
 11248           if (!(c == ' ' || c == '\t' || c == '\n' || c == '\r'))
 11249             break;
 11250           inc_both (&start, &bpos);
 11251         }
 11252       while (bpos > BEGV_BYTE)
 11253         {
 11254           dec_both (&start, &bpos);
 11255           c = FETCH_BYTE (bpos);
 11256           if (!(c == ' ' || c == '\t'))
 11257             break;
 11258         }
 11259     }
 11260   else if (CONSP (from))
 11261     {
 11262       start = clip_to_bounds (BEGV, fix_position (XCAR (from)), ZV);
 11263       bpos = CHAR_TO_BYTE (start);
 11264       CHECK_FIXNUM (XCDR (from));
 11265       vertical_offset = XFIXNUM (XCDR (from));
 11266     }
 11267   else
 11268     {
 11269       start = clip_to_bounds (BEGV, fix_position (from), ZV);
 11270       bpos = CHAR_TO_BYTE (start);
 11271     }
 11272 
 11273   SET_TEXT_POS (startp, start, bpos);
 11274 
 11275   if (NILP (to))
 11276     end = ZV;
 11277   else if (EQ (to, Qt))
 11278     {
 11279       end = ZV;
 11280       bpos = ZV_BYTE;
 11281       while (bpos > BEGV_BYTE)
 11282         {
 11283           dec_both (&end, &bpos);
 11284           c = FETCH_BYTE (bpos);
 11285           if (!(c == ' ' || c == '\t' || c == '\n' || c == '\r'))
 11286             {
 11287               inc_both (&end, &bpos);
 11288               break;
 11289             }
 11290         }
 11291       while (bpos < ZV_BYTE)
 11292         {
 11293           c = fetch_char_advance (&end, &bpos);
 11294           if (!(c == ' ' || c == '\t'))
 11295             break;
 11296         }
 11297     }
 11298   else
 11299     end = clip_to_bounds (start, fix_position (to), ZV);
 11300 
 11301   if (RANGED_FIXNUMP (0, x_limit, INT_MAX))
 11302     max_x = XFIXNUM (x_limit);
 11303   else if (!NILP (x_limit))
 11304     max_x = INT_MAX;
 11305 
 11306   if (NILP (y_limit))
 11307     max_y = INT_MAX;
 11308   else if (RANGED_FIXNUMP (0, y_limit, INT_MAX))
 11309     max_y = XFIXNUM (y_limit);
 11310 
 11311   itdata = bidi_shelve_cache ();
 11312 
 11313   start_display (&it, w, startp);
 11314 
 11315   int start_y = it.current_y;
 11316 
 11317   /* It makes no sense to measure dimensions of region of text that
 11318      crosses the point where bidi reordering changes scan direction.
 11319      By using unidirectional movement here we at least support the use
 11320      case of measuring regions of text that have a uniformly R2L
 11321      directionality, and regions that begin and end in text of the
 11322      same directionality.  */
 11323   it.bidi_p = false;
 11324 
 11325   int start_x;
 11326   if (vertical_offset != 0)
 11327     {
 11328       int last_y;
 11329       it.current_y = 0;
 11330 
 11331       move_it_by_lines (&it, 0);
 11332 
 11333       /* `move_it_vertically_backward' is called by move_it_vertically
 11334          to move by a negative value (upwards), but it is not always
 11335          guaranteed to leave the iterator at or above the position
 11336          given by the offset, which this loop ensures.  */
 11337       if (vertical_offset < 0)
 11338         {
 11339           while (it.current_y > vertical_offset)
 11340             {
 11341               last_y = it.current_y;
 11342               move_it_vertically_backward (&it,
 11343                                            (abs (vertical_offset)
 11344                                             + it.current_y));
 11345 
 11346               if (it.current_y == last_y)
 11347                 break;
 11348             }
 11349         }
 11350       else
 11351         {
 11352           move_it_vertically (&it, vertical_offset);
 11353         }
 11354 
 11355       it.current_y = (WINDOW_TAB_LINE_HEIGHT (w)
 11356                       + WINDOW_HEADER_LINE_HEIGHT (w));
 11357       start = clip_to_bounds (BEGV, IT_CHARPOS (it), ZV);
 11358       start_y = it.current_y;
 11359       start_x = it.current_x;
 11360     }
 11361   else
 11362     {
 11363       /* Start at the beginning of the line containing FROM.  Otherwise
 11364          IT.current_x will be incorrectly set to zero at some arbitrary
 11365          non-zero X coordinate.  */
 11366       reseat_at_previous_visible_line_start (&it);
 11367       it.current_x = it.hpos = 0;
 11368       if (IT_CHARPOS (it) != start)
 11369         {
 11370           void *it1data = NULL;
 11371           struct it it1;
 11372 
 11373           SAVE_IT (it1, it, it1data);
 11374           move_it_to (&it, start, -1, -1, -1, MOVE_TO_POS);
 11375           /* We could have a display property at START, in which case
 11376              asking move_it_to to stop at START will overshoot and
 11377              stop at position after START.  So we try again, stopping
 11378              before START, and account for the width of the last
 11379              buffer position manually.  */
 11380           if (IT_CHARPOS (it) > start && start > BEGV)
 11381             {
 11382               ptrdiff_t it1pos = IT_CHARPOS (it1);
 11383               int it1_x = it1.current_x;
 11384 
 11385               RESTORE_IT (&it, &it1, it1data);
 11386               /* If START - 1 is the beginning of screen line,
 11387                  move_it_to will not move, so we need to use a
 11388                  lower-level move_it_in_display_line subroutine, and
 11389                  tell it to move just 1 pixel, so it stops at the next
 11390                  display element.  */
 11391               if (start - 1 > it1pos)
 11392                 move_it_to (&it, start - 1, -1, -1, -1, MOVE_TO_POS);
 11393               else
 11394                 move_it_in_display_line (&it, start, it1_x + 1,
 11395                                          MOVE_TO_POS | MOVE_TO_X);
 11396               move_it_to (&it, start - 1, -1, -1, -1, MOVE_TO_POS);
 11397               start_x = it.current_x;
 11398               /* If we didn't change our buffer position, the pixel
 11399                  width of what's here was not yet accounted for; do it
 11400                  manually.  */
 11401               if (IT_CHARPOS (it) == start - 1)
 11402                 start_x += it.pixel_width;
 11403             }
 11404           else
 11405             {
 11406               start_x = it.current_x;
 11407               bidi_unshelve_cache (it1data, true);
 11408             }
 11409         }
 11410       else
 11411         start_x = it.current_x;
 11412     }
 11413 
 11414   /* Now move to TO.  */
 11415   int move_op = MOVE_TO_POS | MOVE_TO_Y;
 11416   int to_x = -1;
 11417   it.current_y = start_y;
 11418   /* If FROM is on a newline, pretend that we start at the beginning
 11419      of the next line, because the newline takes no place on display.  */
 11420   if (FETCH_BYTE (start) == '\n')
 11421     it.current_x = 0;
 11422   if (!NILP (x_limit))
 11423     {
 11424       it.last_visible_x = max_x;
 11425       /* Actually, we never want move_it_to stop at to_x.  But to make
 11426          sure that move_it_in_display_line_to always moves far enough,
 11427          we set to_x to INT_MAX and specify MOVE_TO_X.  */
 11428       move_op |= MOVE_TO_X;
 11429       to_x = INT_MAX;
 11430     }
 11431 
 11432   void *it2data = NULL;
 11433   struct it it2;
 11434   SAVE_IT (it2, it, it2data);
 11435 
 11436   x = move_it_to (&it, end, to_x, max_y, -1, move_op);
 11437 
 11438   /* We could have a display property at END, in which case asking
 11439      move_it_to to stop at END will overshoot and stop at position
 11440      after END.  So we try again, stopping before END, and account for
 11441      the width of the last buffer position manually.  */
 11442   if (IT_CHARPOS (it) > end)
 11443     {
 11444       end--;
 11445       RESTORE_IT (&it, &it2, it2data);
 11446       x = move_it_to (&it, end, to_x, max_y, -1, move_op);
 11447       /* Add the width of the thing at TO, but only if we didn't
 11448          overshoot it; if we did, it is already accounted for.  Also,
 11449          account for the height of the thing at TO.  */
 11450       if (IT_CHARPOS (it) == end)
 11451         {
 11452           x += it.pixel_width;
 11453 
 11454           /* DTRT if ignore_line_at_end is t.  */
 11455           if (!NILP (ignore_line_at_end))
 11456             doff = (max (it.max_ascent, it.ascent)
 11457                     + max (it.max_descent, it.descent));
 11458           else
 11459             {
 11460               it.max_ascent = max (it.max_ascent, it.ascent);
 11461               it.max_descent = max (it.max_descent, it.descent);
 11462             }
 11463         }
 11464     }
 11465   else
 11466     bidi_unshelve_cache (it2data, true);
 11467 
 11468   if (!NILP (x_limit))
 11469     {
 11470       /* Don't return more than X-LIMIT.  */
 11471       if (x > max_x)
 11472         x = max_x;
 11473     }
 11474 
 11475   /* If text spans more than one screen line, we don't need to adjust
 11476      the x-span for start_x, since the second and subsequent lines
 11477      will begin at zero X coordinate.  */
 11478   if (it.current_y > start_y)
 11479     start_x = 0;
 11480 
 11481   /* Subtract height of header-line and tab-line which was counted
 11482      automatically by start_display.  */
 11483   if (!NILP (ignore_line_at_end))
 11484     y = (it.current_y + doff
 11485          - WINDOW_TAB_LINE_HEIGHT (w)
 11486          - WINDOW_HEADER_LINE_HEIGHT (w));
 11487   else
 11488     y = (it.current_y + it.max_ascent + it.max_descent + doff
 11489          - WINDOW_TAB_LINE_HEIGHT (w) - WINDOW_HEADER_LINE_HEIGHT (w));
 11490 
 11491   /* Don't return more than Y-LIMIT.  */
 11492   if (y > max_y)
 11493     y = max_y;
 11494 
 11495   if ((EQ (mode_lines, Qtab_line) || EQ (mode_lines, Qt))
 11496       && window_wants_tab_line (w))
 11497     /* Add height of tab-line as requested.  */
 11498     {
 11499       Lisp_Object window_tab_line_format
 11500         = window_parameter (w, Qtab_line_format);
 11501 
 11502       y = y + display_mode_line (w, TAB_LINE_FACE_ID,
 11503                                  NILP (window_tab_line_format)
 11504                                  ? BVAR (current_buffer, tab_line_format)
 11505                                  : window_tab_line_format);
 11506     }
 11507 
 11508   if ((EQ (mode_lines, Qheader_line) || EQ (mode_lines, Qt))
 11509       && window_wants_header_line (w))
 11510     {
 11511       Lisp_Object window_header_line_format
 11512         = window_parameter (w, Qheader_line_format);
 11513 
 11514       y = y + display_mode_line (w, HEADER_LINE_FACE_ID,
 11515                                  NILP (window_header_line_format)
 11516                                  ? BVAR (current_buffer, header_line_format)
 11517                                  : window_header_line_format);
 11518     }
 11519 
 11520   if ((EQ (mode_lines, Qmode_line) || EQ (mode_lines, Qt))
 11521       && window_wants_mode_line (w))
 11522     {
 11523       Lisp_Object window_mode_line_format
 11524         = window_parameter (w, Qmode_line_format);
 11525 
 11526       y = y + display_mode_line (w, CURRENT_MODE_LINE_ACTIVE_FACE_ID (w),
 11527                                  NILP (window_mode_line_format)
 11528                                  ? BVAR (current_buffer, mode_line_format)
 11529                                  : window_mode_line_format);
 11530     }
 11531 
 11532   bidi_unshelve_cache (itdata, false);
 11533 
 11534   return (!vertical_offset
 11535           ? Fcons (make_fixnum (x - start_x), make_fixnum (y))
 11536           : list3i (x - start_x, y, start));
 11537 }
 11538 
 11539 DEFUN ("window-text-pixel-size", Fwindow_text_pixel_size, Swindow_text_pixel_size, 0, 7, 0,
 11540        doc: /* Return the size of the text of WINDOW's buffer in pixels.
 11541 WINDOW must be a live window and defaults to the selected one.  The
 11542 return value is a cons of the maximum pixel-width of any text line and
 11543 the pixel-height of all the text lines in the accessible portion of
 11544 buffer text.
 11545 
 11546 If FROM is a cons cell, the return value includes, in addition to the
 11547 dimensions, also a third element that provides the buffer position
 11548 from which measuring of the text dimensions was actually started.
 11549 
 11550 This function exists to allow Lisp programs to adjust the dimensions
 11551 of WINDOW to the buffer text it needs to display.
 11552 
 11553 The optional argument FROM, if non-nil, specifies the first text
 11554 position to consider, and defaults to the minimum accessible position
 11555 of the buffer.  If FROM is a cons, its car specifies a buffer
 11556 position, and its cdr specifies the vertical offset in pixels from
 11557 that position to the first screen line to be measured.  If FROM is t,
 11558 it stands for the minimum accessible position that starts a non-empty
 11559 line.  TO, if non-nil, specifies the last text position and defaults
 11560 to the maximum accessible position of the buffer.  If TO is t, it
 11561 stands for the maximum accessible position that ends a non-empty line.
 11562 
 11563 The optional argument X-LIMIT, if non-nil, specifies the maximum X
 11564 coordinate beyond which the text should be ignored.  It is therefore
 11565 also the maximum width that the function can return.  X-LIMIT nil or
 11566 omitted means to use the pixel-width of WINDOW's body.  This default
 11567 means text of truncated lines wider than the window will be ignored;
 11568 specify a non-nil value for X-LIMIT if lines are truncated and you need
 11569 to account for the truncated text.
 11570 
 11571 Use nil for X-LIMIT if you want to know how high WINDOW should become in
 11572 order to fit all of its buffer's text with the width of WINDOW
 11573 unaltered.  Use the maximum width WINDOW may assume if you intend to
 11574 change WINDOW's width.  Use t for the maximum possible value.  Since
 11575 calculating the width of long lines can take some time, it's always a
 11576 good idea to make this argument as small as possible; in particular, if
 11577 the buffer contains long lines that shall be truncated anyway.
 11578 
 11579 The optional argument Y-LIMIT, if non-nil, specifies the maximum Y
 11580 coordinate beyond which the text is to be ignored; it is therefore
 11581 also the maximum height that the function can return (excluding the
 11582 height of the mode- or header-line, if any).  Y-LIMIT nil or omitted
 11583 means consider all of the accessible portion of buffer text up to the
 11584 position specified by TO.  Since calculating the text height of a
 11585 large buffer can take some time, it makes sense to specify this
 11586 argument if the size of the buffer is large or unknown.
 11587 
 11588 Optional argument MODE-LINES nil or omitted means do not include the
 11589 height of the mode-, tab- or header-line of WINDOW in the return value.
 11590 If it is the symbol `mode-line', `tab-line' or `header-line', include
 11591 only the height of that line, if present, in the return value.  If t,
 11592 include the height of any of these, if present, in the return value.
 11593 
 11594 IGNORE-LINE-AT-END, if non-nil, means to not add the height of the
 11595 screen line that includes TO to the returned height of the text.  */)
 11596   (Lisp_Object window, Lisp_Object from, Lisp_Object to, Lisp_Object x_limit,
 11597    Lisp_Object y_limit, Lisp_Object mode_lines, Lisp_Object ignore_line_at_end)
 11598 {
 11599   struct window *w = decode_live_window (window);
 11600   struct buffer *b = XBUFFER (w->contents);
 11601   struct buffer *old_b = NULL;
 11602   Lisp_Object value;
 11603 
 11604   if (b != current_buffer)
 11605     {
 11606       old_b = current_buffer;
 11607       set_buffer_internal_1 (b);
 11608     }
 11609 
 11610   value = window_text_pixel_size (window, from, to, x_limit, y_limit, mode_lines,
 11611                                   ignore_line_at_end);
 11612 
 11613   if (old_b)
 11614     set_buffer_internal_1 (old_b);
 11615 
 11616   return value;
 11617 }
 11618 
 11619 DEFUN ("buffer-text-pixel-size", Fbuffer_text_pixel_size, Sbuffer_text_pixel_size, 0, 4, 0,
 11620        doc: /* Return size of whole text of BUFFER-OR-NAME in WINDOW.
 11621 BUFFER-OR-NAME must specify a live buffer or the name of a live buffer
 11622 and defaults to the current buffer.  WINDOW must be a live window and
 11623 defaults to the selected one.  The return value is a cons of the maximum
 11624 pixel-width of any text line and the pixel-height of all the text lines
 11625 of the buffer specified by BUFFER-OR-NAME.
 11626 
 11627 The optional arguments X-LIMIT and Y-LIMIT have the same meaning as with
 11628 `window-text-pixel-size'.
 11629 
 11630 Do not use this function if the buffer specified by BUFFER-OR-NAME is
 11631 already displayed in WINDOW.  `window-text-pixel-size' is cheaper in
 11632 that case because it does not have to temporarily show that buffer in
 11633 WINDOW.  */)
 11634   (Lisp_Object buffer_or_name, Lisp_Object window, Lisp_Object x_limit,
 11635    Lisp_Object y_limit)
 11636 {
 11637   struct window *w = decode_live_window (window);
 11638   struct buffer *b = (NILP (buffer_or_name)
 11639                       ? current_buffer
 11640                       : XBUFFER (Fget_buffer (buffer_or_name)));
 11641   Lisp_Object buffer, value;
 11642   specpdl_ref count = SPECPDL_INDEX ();
 11643 
 11644   XSETBUFFER (buffer, b);
 11645 
 11646   /* The unwind form of with_echo_area_buffer is what we need here to
 11647      make WINDOW temporarily show our buffer.  */
 11648   /* FIXME: Can we move this into the `if (!EQ (buffer, w->contents))`?  */
 11649   record_unwind_protect (unwind_with_echo_area_buffer,
 11650                          with_echo_area_buffer_unwind_data (w));
 11651 
 11652   set_buffer_internal_1 (b);
 11653 
 11654   ptrdiff_t base_line_pos = w->base_line_pos;
 11655   int end_valid = w->window_end_valid;
 11656   if (!EQ (buffer, w->contents))
 11657     {
 11658       wset_buffer (w, buffer);
 11659       set_marker_both (w->pointm, buffer, BEG, BEG_BYTE);
 11660       set_marker_both (w->old_pointm, buffer, BEG, BEG_BYTE);
 11661     }
 11662 
 11663   value = window_text_pixel_size (window, Qnil, Qnil, x_limit, y_limit, Qnil,
 11664                                   Qnil);
 11665 
 11666   unbind_to (count, Qnil);
 11667 
 11668   /* Restore original values.  This is important if this function is
 11669      called from some ':eval' form in the middle of redisplay.  */
 11670   w->base_line_pos = base_line_pos;
 11671   w->window_end_valid = end_valid;
 11672 
 11673   return value;
 11674 }
 11675 
 11676 
 11677 DEFUN ("display--line-is-continued-p", Fdisplay__line_is_continued_p,
 11678        Sdisplay__line_is_continued_p, 0, 0, 0,
 11679        doc: /* Return non-nil if the current screen line is continued on display.  */)
 11680   (void)
 11681 {
 11682   struct buffer *oldb = current_buffer;
 11683   struct window *w = XWINDOW (selected_window);
 11684   enum move_it_result rc = MOVE_POS_MATCH_OR_ZV;
 11685 
 11686   set_buffer_internal_1 (XBUFFER (w->contents));
 11687 
 11688   if (PT < ZV)
 11689     {
 11690       struct text_pos startpos;
 11691       struct it it;
 11692       void *itdata;
 11693       /* Use a marker, since vertical-motion enters redisplay, which can
 11694          trigger fontifications, which in turn could modify buffer text.  */
 11695       Lisp_Object opoint = Fpoint_marker ();
 11696 
 11697       /* Make sure to start from the beginning of the current screen
 11698          line, so that move_it_in_display_line_to counts pixels correctly.  */
 11699       Fvertical_motion (make_fixnum (0), selected_window, Qnil);
 11700       SET_TEXT_POS (startpos, PT, PT_BYTE);
 11701       itdata = bidi_shelve_cache ();
 11702       start_display (&it, w, startpos);
 11703       /* If lines are truncated, no line is continued.  */
 11704       if (it.line_wrap != TRUNCATE)
 11705         {
 11706           it.glyph_row = NULL;
 11707           rc = move_it_in_display_line_to (&it, ZV, -1, MOVE_TO_POS);
 11708         }
 11709       SET_PT_BOTH (marker_position (opoint), marker_byte_position (opoint));
 11710       bidi_unshelve_cache (itdata, false);
 11711     }
 11712   set_buffer_internal_1 (oldb);
 11713 
 11714   return rc == MOVE_LINE_CONTINUED ? Qt : Qnil;
 11715 }
 11716 
 11717 
 11718 /***********************************************************************
 11719                                Messages
 11720  ***********************************************************************/
 11721 
 11722 /* Return the number of arguments the format string FORMAT needs.  */
 11723 
 11724 static ptrdiff_t
 11725 format_nargs (char const *format)
 11726 {
 11727   ptrdiff_t nargs = 0;
 11728   for (char const *p = format; (p = strchr (p, '%')); p++)
 11729     if (p[1] == '%')
 11730       p++;
 11731     else
 11732       nargs++;
 11733   return nargs;
 11734 }
 11735 
 11736 /* Add a message with format string FORMAT and formatted arguments
 11737    to *Messages*.  */
 11738 
 11739 void
 11740 add_to_log (const char *format, ...)
 11741 {
 11742   va_list ap;
 11743   va_start (ap, format);
 11744   vadd_to_log (format, ap);
 11745   va_end (ap);
 11746 }
 11747 
 11748 void
 11749 vadd_to_log (char const *format, va_list ap)
 11750 {
 11751   ptrdiff_t form_nargs = format_nargs (format);
 11752   ptrdiff_t nargs = 1 + form_nargs;
 11753   Lisp_Object args[10];
 11754   eassert (nargs <= ARRAYELTS (args));
 11755   AUTO_STRING (args0, format);
 11756   args[0] = args0;
 11757   for (ptrdiff_t i = 1; i <= nargs; i++)
 11758     args[i] = va_arg (ap, Lisp_Object);
 11759   Lisp_Object msg = Qnil;
 11760   msg = Fformat_message (nargs, args);
 11761 
 11762   ptrdiff_t len = SBYTES (msg) + 1;
 11763   USE_SAFE_ALLOCA;
 11764   char *buffer = SAFE_ALLOCA (len);
 11765   memcpy (buffer, SDATA (msg), len);
 11766 
 11767   message_dolog (buffer, len - 1, true, STRING_MULTIBYTE (msg));
 11768   SAFE_FREE ();
 11769 }
 11770 
 11771 
 11772 /* Output a newline in the *Messages* buffer if "needs" one.  */
 11773 
 11774 void
 11775 message_log_maybe_newline (void)
 11776 {
 11777   if (message_log_need_newline)
 11778     message_dolog ("", 0, true, false);
 11779 }
 11780 
 11781 
 11782 /* Add a string M of length NBYTES to the message log, optionally
 11783    terminated with a newline when NLFLAG is true.  MULTIBYTE, if
 11784    true, means interpret the contents of M as multibyte.  This
 11785    function calls low-level routines in order to bypass text property
 11786    hooks, etc. which might not be safe to run.
 11787 
 11788    This may GC (insert may run before/after change hooks),
 11789    so the buffer M must NOT point to a Lisp string.  */
 11790 
 11791 void
 11792 message_dolog (const char *m, ptrdiff_t nbytes, bool nlflag, bool multibyte)
 11793 {
 11794   const unsigned char *msg = (const unsigned char *) m;
 11795 
 11796   if (!NILP (Vmemory_full))
 11797     return;
 11798 
 11799   if (!NILP (Vmessage_log_max))
 11800     {
 11801       struct buffer *oldbuf;
 11802       Lisp_Object oldpoint, oldbegv, oldzv;
 11803       int old_windows_or_buffers_changed = windows_or_buffers_changed;
 11804       ptrdiff_t point_at_end = 0;
 11805       ptrdiff_t zv_at_end = 0;
 11806       Lisp_Object old_deactivate_mark;
 11807 
 11808       old_deactivate_mark = Vdeactivate_mark;
 11809       oldbuf = current_buffer;
 11810 
 11811       /* Sanity check, in case the variable has been set to something
 11812          invalid.  */
 11813       if (! STRINGP (Vmessages_buffer_name))
 11814         Vmessages_buffer_name = build_string ("*Messages*");
 11815       /* Ensure the Messages buffer exists, and switch to it.
 11816          If we created it, set the major-mode.  */
 11817       bool newbuffer = NILP (Fget_buffer (Vmessages_buffer_name));
 11818       Fset_buffer (Fget_buffer_create (Vmessages_buffer_name, Qnil));
 11819       if (newbuffer
 11820           && !NILP (Ffboundp (intern ("messages-buffer-mode"))))
 11821         call0 (intern ("messages-buffer-mode"));
 11822 
 11823       bset_undo_list (current_buffer, Qt);
 11824       bset_cache_long_scans (current_buffer, Qnil);
 11825 
 11826       oldpoint = message_dolog_marker1;
 11827       set_marker_restricted_both (oldpoint, Qnil, PT, PT_BYTE);
 11828       oldbegv = message_dolog_marker2;
 11829       set_marker_restricted_both (oldbegv, Qnil, BEGV, BEGV_BYTE);
 11830       oldzv = message_dolog_marker3;
 11831       set_marker_restricted_both (oldzv, Qnil, ZV, ZV_BYTE);
 11832 
 11833       if (PT == Z)
 11834         point_at_end = 1;
 11835       if (ZV == Z)
 11836         zv_at_end = 1;
 11837 
 11838       BEGV = BEG;
 11839       BEGV_BYTE = BEG_BYTE;
 11840       ZV = Z;
 11841       ZV_BYTE = Z_BYTE;
 11842       TEMP_SET_PT_BOTH (Z, Z_BYTE);
 11843 
 11844       /* Insert the string--maybe converting multibyte to single byte
 11845          or vice versa, so that all the text fits the buffer.  */
 11846       if (multibyte
 11847           && NILP (BVAR (current_buffer, enable_multibyte_characters)))
 11848         {
 11849           /* Convert a multibyte string to single-byte
 11850              for the *Message* buffer.  */
 11851           for (ptrdiff_t i = 0; i < nbytes; )
 11852             {
 11853               int char_bytes, c = check_char_and_length (msg + i, &char_bytes);
 11854               char work = CHAR_TO_BYTE8 (c);
 11855               insert_1_both (&work, 1, 1, true, false, false);
 11856               i += char_bytes;
 11857             }
 11858         }
 11859       else if (! multibyte
 11860                && ! NILP (BVAR (current_buffer, enable_multibyte_characters)))
 11861         {
 11862           /* Convert a single-byte string to multibyte
 11863              for the *Message* buffer.  */
 11864           for (ptrdiff_t i = 0; i < nbytes; i++)
 11865             {
 11866               int c = make_char_multibyte (msg[i]);
 11867               unsigned char str[MAX_MULTIBYTE_LENGTH];
 11868               int char_bytes = CHAR_STRING (c, str);
 11869               insert_1_both ((char *) str, 1, char_bytes, true, false, false);
 11870             }
 11871         }
 11872       else if (nbytes)
 11873         insert_1_both (m, chars_in_text (msg, nbytes), nbytes,
 11874                        true, false, false);
 11875 
 11876       if (nlflag)
 11877         {
 11878           ptrdiff_t this_bol, this_bol_byte, prev_bol, prev_bol_byte;
 11879           intmax_t dups;
 11880 
 11881           /* Since we call del_range_both passing false for PREPARE,
 11882              we aren't prepared to run modification hooks (we could
 11883              end up calling modification hooks from another buffer and
 11884              only with AFTER=t, Bug#21824).  */
 11885           specpdl_ref count = SPECPDL_INDEX ();
 11886           specbind (Qinhibit_modification_hooks, Qt);
 11887 
 11888           insert_1_both ("\n", 1, 1, true, false, false);
 11889 
 11890           scan_newline (Z, Z_BYTE, BEG, BEG_BYTE, -2, false);
 11891           this_bol = PT;
 11892           this_bol_byte = PT_BYTE;
 11893 
 11894           /* See if this line duplicates the previous one.
 11895              If so, combine duplicates.  */
 11896           if (this_bol > BEG)
 11897             {
 11898               scan_newline (PT, PT_BYTE, BEG, BEG_BYTE, -2, false);
 11899               prev_bol = PT;
 11900               prev_bol_byte = PT_BYTE;
 11901 
 11902               dups = message_log_check_duplicate (prev_bol_byte,
 11903                                                   this_bol_byte);
 11904               if (dups)
 11905                 {
 11906                   del_range_both (prev_bol, prev_bol_byte,
 11907                                   this_bol, this_bol_byte, false);
 11908                   if (dups > 1)
 11909                     {
 11910                       char dupstr[sizeof " [ times]"
 11911                                   + INT_STRLEN_BOUND (dups)];
 11912 
 11913                       /* If you change this format, don't forget to also
 11914                          change message_log_check_duplicate.  */
 11915                       int duplen = sprintf (dupstr, " [%"PRIdMAX" times]",
 11916                                             dups);
 11917                       TEMP_SET_PT_BOTH (Z - 1, Z_BYTE - 1);
 11918                       insert_1_both (dupstr, duplen, duplen,
 11919                                      true, false, true);
 11920                     }
 11921                 }
 11922             }
 11923 
 11924           /* If we have more than the desired maximum number of lines
 11925              in the *Messages* buffer now, delete the oldest ones.
 11926              This is safe because we don't have undo in this buffer.  */
 11927 
 11928           if (FIXNATP (Vmessage_log_max))
 11929             {
 11930               scan_newline (Z, Z_BYTE, BEG, BEG_BYTE,
 11931                             -XFIXNAT (Vmessage_log_max) - 1, false);
 11932               del_range_both (BEG, BEG_BYTE, PT, PT_BYTE, false);
 11933             }
 11934 
 11935           unbind_to (count, Qnil);
 11936         }
 11937       BEGV = marker_position (oldbegv);
 11938       BEGV_BYTE = marker_byte_position (oldbegv);
 11939 
 11940       if (zv_at_end)
 11941         {
 11942           ZV = Z;
 11943           ZV_BYTE = Z_BYTE;
 11944         }
 11945       else
 11946         {
 11947           ZV = marker_position (oldzv);
 11948           ZV_BYTE = marker_byte_position (oldzv);
 11949         }
 11950 
 11951       if (point_at_end)
 11952         TEMP_SET_PT_BOTH (Z, Z_BYTE);
 11953       else
 11954         /* We can't do Fgoto_char (oldpoint) because it will run some
 11955            Lisp code.  */
 11956         TEMP_SET_PT_BOTH (marker_position (oldpoint),
 11957                           marker_byte_position (oldpoint));
 11958 
 11959       unchain_marker (XMARKER (oldpoint));
 11960       unchain_marker (XMARKER (oldbegv));
 11961       unchain_marker (XMARKER (oldzv));
 11962 
 11963       /* We called insert_1_both above with its 5th argument (PREPARE)
 11964          false, which prevents insert_1_both from calling
 11965          prepare_to_modify_buffer, which in turns prevents us from
 11966          incrementing windows_or_buffers_changed even if *Messages* is
 11967          shown in some window.  So we must manually set
 11968          windows_or_buffers_changed here to make up for that.  */
 11969       windows_or_buffers_changed = old_windows_or_buffers_changed;
 11970       bset_redisplay (current_buffer);
 11971 
 11972       set_buffer_internal (oldbuf);
 11973 
 11974       message_log_need_newline = !nlflag;
 11975       Vdeactivate_mark = old_deactivate_mark;
 11976     }
 11977 }
 11978 
 11979 
 11980 /* We are at the end of the buffer after just having inserted a newline.
 11981    (Note: We depend on the fact we won't be crossing the gap.)
 11982    Check to see if the most recent message looks a lot like the previous one.
 11983    Return 0 if different, 1 if the new one should just replace it, or a
 11984    value N > 1 if we should also append " [N times]".  */
 11985 
 11986 static intmax_t
 11987 message_log_check_duplicate (ptrdiff_t prev_bol_byte, ptrdiff_t this_bol_byte)
 11988 {
 11989   ptrdiff_t i;
 11990   ptrdiff_t len = Z_BYTE - 1 - this_bol_byte;
 11991   bool seen_dots = false;
 11992   unsigned char *p1 = BUF_BYTE_ADDRESS (current_buffer, prev_bol_byte);
 11993   unsigned char *p2 = BUF_BYTE_ADDRESS (current_buffer, this_bol_byte);
 11994 
 11995   for (i = 0; i < len; i++)
 11996     {
 11997       if (i >= 3 && p1[i - 3] == '.' && p1[i - 2] == '.' && p1[i - 1] == '.')
 11998         seen_dots = true;
 11999       if (p1[i] != p2[i])
 12000         return seen_dots;
 12001     }
 12002   p1 += len;
 12003   if (*p1 == '\n')
 12004     return 2;
 12005   if (*p1++ == ' ' && *p1++ == '[')
 12006     {
 12007       char *pend;
 12008       intmax_t n = strtoimax ((char *) p1, &pend, 10);
 12009       if (0 < n && n < INTMAX_MAX && strncmp (pend, " times]\n", 8) == 0)
 12010         return n + 1;
 12011     }
 12012   return 0;
 12013 }
 12014 
 12015 
 12016 /* Display an echo area message M with a specified length of NBYTES
 12017    bytes.  The string may include null characters.  If M is not a
 12018    string, clear out any existing message, and let the mini-buffer
 12019    text show through.
 12020 
 12021    This function cancels echoing.  */
 12022 
 12023 void
 12024 message3 (Lisp_Object m)
 12025 {
 12026   clear_message (true, true);
 12027   cancel_echoing ();
 12028 
 12029   /* First flush out any partial line written with print.  */
 12030   message_log_maybe_newline ();
 12031   if (STRINGP (m))
 12032     {
 12033       ptrdiff_t nbytes = SBYTES (m);
 12034       bool multibyte = STRING_MULTIBYTE (m);
 12035       char *buffer;
 12036       USE_SAFE_ALLOCA;
 12037       SAFE_ALLOCA_STRING (buffer, m);
 12038       message_dolog (buffer, nbytes, true, multibyte);
 12039       SAFE_FREE ();
 12040     }
 12041   if (! inhibit_message)
 12042     message3_nolog (m);
 12043 }
 12044 
 12045 /* Log the message M to stderr.  Log an empty line if M is not a string.  */
 12046 
 12047 static void
 12048 message_to_stderr (Lisp_Object m)
 12049 {
 12050   if (noninteractive_need_newline)
 12051     {
 12052       noninteractive_need_newline = false;
 12053       errputc ('\n');
 12054     }
 12055   if (STRINGP (m))
 12056     {
 12057       Lisp_Object coding_system = Vlocale_coding_system;
 12058       Lisp_Object s;
 12059 
 12060       if (!NILP (Vcoding_system_for_write))
 12061         coding_system = Vcoding_system_for_write;
 12062       if (!NILP (coding_system))
 12063         s = code_convert_string_norecord (m, coding_system, true);
 12064       else
 12065         s = m;
 12066 
 12067       errwrite (SDATA (s), SBYTES (s));
 12068     }
 12069   if (STRINGP (m) || !cursor_in_echo_area)
 12070     errputc ('\n');
 12071 }
 12072 
 12073 /* The non-logging version of message3.
 12074    This does not cancel echoing, because it is used for echoing.
 12075    Perhaps we need to make a separate function for echoing
 12076    and make this cancel echoing.  */
 12077 
 12078 void
 12079 message3_nolog (Lisp_Object m)
 12080 {
 12081   struct frame *sf = SELECTED_FRAME ();
 12082 
 12083   if (FRAME_INITIAL_P (sf))
 12084     message_to_stderr (m);
 12085   /* Error messages get reported properly by cmd_error, so this must be just an
 12086      informative message; if the frame hasn't really been initialized yet, just
 12087      toss it.  */
 12088   else if (INTERACTIVE && sf->glyphs_initialized_p)
 12089     {
 12090       /* Get the frame containing the mini-buffer
 12091          that the selected frame is using.  */
 12092       Lisp_Object mini_window = FRAME_MINIBUF_WINDOW (sf);
 12093       Lisp_Object frame = XWINDOW (mini_window)->frame;
 12094       struct frame *f = XFRAME (frame);
 12095 
 12096       if (FRAME_VISIBLE_P (sf) && !FRAME_VISIBLE_P (f))
 12097         Fmake_frame_visible (frame);
 12098 
 12099       if (STRINGP (m) && SCHARS (m) > 0)
 12100         {
 12101           set_message (m);
 12102           if (minibuffer_auto_raise)
 12103             Fraise_frame (frame);
 12104           /* Assume we are not echoing.
 12105              (If we are, echo_now will override this.)  */
 12106           echo_message_buffer = Qnil;
 12107         }
 12108       else
 12109         clear_message (true, true);
 12110 
 12111       do_pending_window_change (false);
 12112       echo_area_display (true);
 12113       do_pending_window_change (false);
 12114       if (FRAME_TERMINAL (f)->frame_up_to_date_hook)
 12115         (*FRAME_TERMINAL (f)->frame_up_to_date_hook) (f);
 12116     }
 12117 }
 12118 
 12119 
 12120 /* Display a null-terminated echo area message M.  If M is 0, clear
 12121    out any existing message, and let the mini-buffer text show through.
 12122 
 12123    The buffer M must continue to exist until after the echo area gets
 12124    cleared or some other message gets displayed there.  Do not pass
 12125    text that is stored in a Lisp string.  Do not pass text in a buffer
 12126    that was alloca'd.  */
 12127 
 12128 void
 12129 message1 (const char *m)
 12130 {
 12131   message3 (m ? build_unibyte_string (m) : Qnil);
 12132 }
 12133 
 12134 
 12135 /* The non-logging counterpart of message1.  */
 12136 
 12137 void
 12138 message1_nolog (const char *m)
 12139 {
 12140   message3_nolog (m ? build_unibyte_string (m) : Qnil);
 12141 }
 12142 
 12143 /* Display a message M which contains a single %s
 12144    which gets replaced with STRING.  */
 12145 
 12146 void
 12147 message_with_string (const char *m, Lisp_Object string, bool log)
 12148 {
 12149   CHECK_STRING (string);
 12150 
 12151   bool need_message;
 12152   if (noninteractive)
 12153     need_message = !!m;
 12154   else if (!INTERACTIVE)
 12155     need_message = false;
 12156   else
 12157     {
 12158       /* The frame whose minibuffer we're going to display the message on.
 12159          It may be larger than the selected frame, so we need
 12160          to use its buffer, not the selected frame's buffer.  */
 12161       Lisp_Object mini_window;
 12162       struct frame *f, *sf = SELECTED_FRAME ();
 12163 
 12164       /* Get the frame containing the minibuffer
 12165          that the selected frame is using.  */
 12166       mini_window = FRAME_MINIBUF_WINDOW (sf);
 12167       f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
 12168 
 12169       /* Error messages get reported properly by cmd_error, so this must be
 12170          just an informative message; if the frame hasn't really been
 12171          initialized yet, just toss it.  */
 12172       need_message = f->glyphs_initialized_p;
 12173     }
 12174 
 12175   if (need_message)
 12176     {
 12177       AUTO_STRING (fmt, m);
 12178       Lisp_Object msg = CALLN (Fformat_message, fmt, string);
 12179 
 12180       if (noninteractive)
 12181         message_to_stderr (msg);
 12182       else
 12183         {
 12184           if (log)
 12185             message3 (msg);
 12186           else
 12187             message3_nolog (msg);
 12188 
 12189           /* Print should start at the beginning of the message
 12190              buffer next time.  */
 12191           message_buf_print = false;
 12192         }
 12193     }
 12194 }
 12195 
 12196 
 12197 /* Dump an informative message to the minibuf.  If M is 0, clear out
 12198    any existing message, and let the mini-buffer text show through.
 12199 
 12200    The message must be safe ASCII (because when Emacs is
 12201    non-interactive the message is sent straight to stderr without
 12202    encoding first) and the format must not contain ` or ' (because
 12203    this function does not account for `text-quoting-style').  If your
 12204    message and format do not fit into this category, convert your
 12205    arguments to Lisp objects and use Fmessage instead.  */
 12206 
 12207 static void ATTRIBUTE_FORMAT_PRINTF (1, 0)
 12208 vmessage (const char *m, va_list ap)
 12209 {
 12210   if (noninteractive)
 12211     {
 12212       if (m)
 12213         {
 12214           if (noninteractive_need_newline)
 12215             putc ('\n', stderr);
 12216           noninteractive_need_newline = false;
 12217           vfprintf (stderr, m, ap);
 12218           if (!cursor_in_echo_area)
 12219             putc ('\n', stderr);
 12220           fflush (stderr);
 12221         }
 12222     }
 12223   else if (INTERACTIVE)
 12224     {
 12225       /* The frame whose mini-buffer we're going to display the message
 12226          on.  It may be larger than the selected frame, so we need to
 12227          use its buffer, not the selected frame's buffer.  */
 12228       Lisp_Object mini_window;
 12229       struct frame *f, *sf = SELECTED_FRAME ();
 12230 
 12231       /* Get the frame containing the mini-buffer
 12232          that the selected frame is using.  */
 12233       mini_window = FRAME_MINIBUF_WINDOW (sf);
 12234       f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
 12235 
 12236       /* Error messages get reported properly by cmd_error, so this must be
 12237          just an informative message; if the frame hasn't really been
 12238          initialized yet, just toss it.  */
 12239       if (f->glyphs_initialized_p)
 12240         {
 12241           if (m)
 12242             {
 12243               ptrdiff_t len;
 12244               ptrdiff_t maxsize = FRAME_MESSAGE_BUF_SIZE (f);
 12245               USE_SAFE_ALLOCA;
 12246               char *message_buf = SAFE_ALLOCA (maxsize + 1);
 12247 
 12248               len = doprnt (message_buf, maxsize, m, 0, ap);
 12249 
 12250               message3 (make_string (message_buf, len));
 12251               SAFE_FREE ();
 12252             }
 12253           else
 12254             message1 (0);
 12255 
 12256           /* Print should start at the beginning of the message
 12257              buffer next time.  */
 12258           message_buf_print = false;
 12259         }
 12260     }
 12261 }
 12262 
 12263 /* See vmessage for restrictions on the text of the message.  */
 12264 void
 12265 message (const char *m, ...)
 12266 {
 12267   va_list ap;
 12268   va_start (ap, m);
 12269   vmessage (m, ap);
 12270   va_end (ap);
 12271 }
 12272 
 12273 
 12274 /* Display the current message in the current mini-buffer.  This is
 12275    only called from error handlers in process.c, and is not time
 12276    critical.  */
 12277 
 12278 void
 12279 update_echo_area (void)
 12280 {
 12281   if (!NILP (echo_area_buffer[0]))
 12282     {
 12283       Lisp_Object string;
 12284       string = Fcurrent_message ();
 12285       message3 (string);
 12286     }
 12287 }
 12288 
 12289 
 12290 /* Make sure echo area buffers in `echo_buffers' are live.
 12291    If they aren't, make new ones.  */
 12292 
 12293 static void
 12294 ensure_echo_area_buffers (void)
 12295 {
 12296   for (int i = 0; i < 2; i++)
 12297     if (!BUFFERP (echo_buffer[i])
 12298         || !BUFFER_LIVE_P (XBUFFER (echo_buffer[i])))
 12299       {
 12300         Lisp_Object old_buffer = echo_buffer[i];
 12301         static char const name_fmt[] = " *Echo Area %d*";
 12302         char name[sizeof name_fmt + INT_STRLEN_BOUND (int)];
 12303         AUTO_STRING_WITH_LEN (lname, name, sprintf (name, name_fmt, i));
 12304         echo_buffer[i] = Fget_buffer_create (lname, Qnil);
 12305         bset_truncate_lines (XBUFFER (echo_buffer[i]), Qnil);
 12306         /* to force word wrap in echo area -
 12307            it was decided to postpone this*/
 12308         /* XBUFFER (echo_buffer[i])->word_wrap = Qt; */
 12309 
 12310         for (int j = 0; j < 2; j++)
 12311           if (EQ (old_buffer, echo_area_buffer[j]))
 12312             echo_area_buffer[j] = echo_buffer[i];
 12313       }
 12314 }
 12315 
 12316 
 12317 /* Call FN with args A1..A2 with either the current or last displayed
 12318    echo_area_buffer as current buffer.
 12319 
 12320    WHICH zero means use the current message buffer
 12321    echo_area_buffer[0].  If that is nil, choose a suitable buffer
 12322    from echo_buffer[] and clear it.
 12323 
 12324    WHICH > 0 means use echo_area_buffer[1].  If that is nil, choose a
 12325    suitable buffer from echo_buffer[] and clear it.
 12326 
 12327    If WHICH < 0, set echo_area_buffer[1] to echo_area_buffer[0], so
 12328    that the current message becomes the last displayed one, choose a
 12329    suitable buffer for echo_area_buffer[0], and clear it.
 12330 
 12331    Value is what FN returns.  */
 12332 
 12333 static bool
 12334 with_echo_area_buffer (struct window *w, int which,
 12335                        bool (*fn) (void *, Lisp_Object),
 12336                        void *a1, Lisp_Object a2)
 12337 {
 12338   Lisp_Object buffer;
 12339   bool this_one, the_other, clear_buffer_p, rc;
 12340   specpdl_ref count = SPECPDL_INDEX ();
 12341 
 12342   /* If buffers aren't live, make new ones.  */
 12343   ensure_echo_area_buffers ();
 12344 
 12345   clear_buffer_p = false;
 12346 
 12347   if (which == 0)
 12348     this_one = false, the_other = true;
 12349   else if (which > 0)
 12350     this_one = true, the_other = false;
 12351   else
 12352     {
 12353       this_one = false, the_other = true;
 12354       clear_buffer_p = true;
 12355 
 12356       /* We need a fresh one in case the current echo buffer equals
 12357          the one containing the last displayed echo area message.  */
 12358       if (!NILP (echo_area_buffer[this_one])
 12359           && EQ (echo_area_buffer[this_one], echo_area_buffer[the_other]))
 12360         echo_area_buffer[this_one] = Qnil;
 12361     }
 12362 
 12363   /* Choose a suitable buffer from echo_buffer[] if we don't
 12364      have one.  */
 12365   if (NILP (echo_area_buffer[this_one]))
 12366     {
 12367       echo_area_buffer[this_one]
 12368         = (EQ (echo_area_buffer[the_other], echo_buffer[this_one])
 12369            ? echo_buffer[the_other]
 12370            : echo_buffer[this_one]);
 12371       clear_buffer_p = true;
 12372     }
 12373 
 12374   buffer = echo_area_buffer[this_one];
 12375 
 12376   /* Don't get confused by reusing the buffer used for echoing
 12377      for a different purpose.  */
 12378   if (echo_kboard == NULL && EQ (buffer, echo_message_buffer))
 12379     cancel_echoing ();
 12380 
 12381   record_unwind_protect (unwind_with_echo_area_buffer,
 12382                          with_echo_area_buffer_unwind_data (w));
 12383 
 12384   /* Make the echo area buffer current.  Note that for display
 12385      purposes, it is not necessary that the displayed window's buffer
 12386      == current_buffer, except for text property lookup.  So, let's
 12387      only set that buffer temporarily here without doing a full
 12388      Fset_window_buffer.  We must also change w->pointm, though,
 12389      because otherwise an assertions in unshow_buffer fails, and Emacs
 12390      aborts.  */
 12391   set_buffer_internal_1 (XBUFFER (buffer));
 12392   if (w)
 12393     {
 12394       wset_buffer (w, buffer);
 12395       set_marker_both (w->pointm, buffer, BEG, BEG_BYTE);
 12396       set_marker_both (w->old_pointm, buffer, BEG, BEG_BYTE);
 12397     }
 12398 
 12399   bset_undo_list (current_buffer, Qt);
 12400   bset_read_only (current_buffer, Qnil);
 12401   specbind (Qinhibit_read_only, Qt);
 12402   specbind (Qinhibit_modification_hooks, Qt);
 12403 
 12404   if (clear_buffer_p && Z > BEG)
 12405     del_range (BEG, Z);
 12406 
 12407   eassert (BEGV >= BEG);
 12408   eassert (ZV <= Z && ZV >= BEGV);
 12409 
 12410   rc = fn (a1, a2);
 12411 
 12412   eassert (BEGV >= BEG);
 12413   eassert (ZV <= Z && ZV >= BEGV);
 12414 
 12415   unbind_to (count, Qnil);
 12416   return rc;
 12417 }
 12418 
 12419 
 12420 /* Save state that should be preserved around the call to the function
 12421    FN called in with_echo_area_buffer.  */
 12422 
 12423 static Lisp_Object
 12424 with_echo_area_buffer_unwind_data (struct window *w)
 12425 {
 12426   int i = 0;
 12427   Lisp_Object vector, tmp;
 12428 
 12429   /* Reduce consing by keeping one vector in
 12430      Vwith_echo_area_save_vector.  */
 12431   vector = Vwith_echo_area_save_vector;
 12432   Vwith_echo_area_save_vector = Qnil;
 12433 
 12434   if (NILP (vector))
 12435     vector = make_nil_vector (11);
 12436 
 12437   XSETBUFFER (tmp, current_buffer); ASET (vector, i, tmp); ++i;
 12438   ASET (vector, i, Vdeactivate_mark); ++i;
 12439   ASET (vector, i, make_fixnum (windows_or_buffers_changed)); ++i;
 12440 
 12441   if (w)
 12442     {
 12443       XSETWINDOW (tmp, w); ASET (vector, i, tmp); ++i;
 12444       ASET (vector, i, w->contents); ++i;
 12445       ASET (vector, i, make_fixnum (marker_position (w->pointm))); ++i;
 12446       ASET (vector, i, make_fixnum (marker_byte_position (w->pointm))); ++i;
 12447       ASET (vector, i, make_fixnum (marker_position (w->old_pointm))); ++i;
 12448       ASET (vector, i, make_fixnum (marker_byte_position (w->old_pointm))); ++i;
 12449       ASET (vector, i, make_fixnum (marker_position (w->start))); ++i;
 12450       ASET (vector, i, make_fixnum (marker_byte_position (w->start))); ++i;
 12451     }
 12452   else
 12453     {
 12454       int end = i + 8;
 12455       for (; i < end; ++i)
 12456         ASET (vector, i, Qnil);
 12457     }
 12458 
 12459   eassert (i == ASIZE (vector));
 12460   return vector;
 12461 }
 12462 
 12463 
 12464 /* Restore global state from VECTOR which was created by
 12465    with_echo_area_buffer_unwind_data.  */
 12466 
 12467 static void
 12468 unwind_with_echo_area_buffer (Lisp_Object vector)
 12469 {
 12470   set_buffer_internal_1 (XBUFFER (AREF (vector, 0)));
 12471   Vdeactivate_mark = AREF (vector, 1);
 12472   windows_or_buffers_changed = XFIXNAT (AREF (vector, 2));
 12473 
 12474   if (WINDOWP (AREF (vector, 3)))
 12475     {
 12476       struct window *w;
 12477       Lisp_Object buffer;
 12478 
 12479       w = XWINDOW (AREF (vector, 3));
 12480       buffer = AREF (vector, 4);
 12481 
 12482       wset_buffer (w, buffer);
 12483       set_marker_restricted_both (w->pointm, buffer,
 12484                                   XFIXNAT (AREF (vector, 5)),
 12485                                   XFIXNAT (AREF (vector, 6)));
 12486       set_marker_restricted_both (w->old_pointm, buffer,
 12487                                   XFIXNAT (AREF (vector, 7)),
 12488                                   XFIXNAT (AREF (vector, 8)));
 12489       set_marker_restricted_both (w->start, buffer,
 12490                                   XFIXNAT (AREF (vector, 9)),
 12491                                   XFIXNAT (AREF (vector, 10)));
 12492     }
 12493 
 12494   Vwith_echo_area_save_vector = vector;
 12495 }
 12496 
 12497 
 12498 /* Set up the echo area for use by print functions.  MULTIBYTE_P
 12499    means we will print multibyte.  */
 12500 
 12501 void
 12502 setup_echo_area_for_printing (bool multibyte_p)
 12503 {
 12504   /* If we can't find an echo area any more, exit.  */
 12505   if (! FRAME_LIVE_P (XFRAME (selected_frame)))
 12506     Fkill_emacs (Qnil, Qnil);
 12507 
 12508   ensure_echo_area_buffers ();
 12509 
 12510   if (!message_buf_print)
 12511     {
 12512       /* A message has been output since the last time we printed.
 12513          Choose a fresh echo area buffer.  */
 12514       if (EQ (echo_area_buffer[1], echo_buffer[0]))
 12515         echo_area_buffer[0] = echo_buffer[1];
 12516       else
 12517         echo_area_buffer[0] = echo_buffer[0];
 12518 
 12519       /* Switch to that buffer and clear it.  */
 12520       set_buffer_internal (XBUFFER (echo_area_buffer[0]));
 12521       bset_truncate_lines (current_buffer, Qnil);
 12522 
 12523       if (Z > BEG)
 12524         {
 12525           specpdl_ref count = SPECPDL_INDEX ();
 12526           specbind (Qinhibit_read_only, Qt);
 12527           /* Note that undo recording is always disabled.  */
 12528           del_range (BEG, Z);
 12529           unbind_to (count, Qnil);
 12530         }
 12531       TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
 12532 
 12533       /* Set up the buffer for the multibyteness we need.  We always
 12534          set it to be multibyte, except when
 12535          unibyte-display-via-language-environment is non-nil and the
 12536          buffer from which we are called is unibyte, because in that
 12537          case unibyte characters should not be displayed as octal
 12538          escapes.  */
 12539       if (unibyte_display_via_language_environment
 12540           && !multibyte_p
 12541           && !NILP (BVAR (current_buffer, enable_multibyte_characters)))
 12542         Fset_buffer_multibyte (Qnil);
 12543       else if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
 12544         Fset_buffer_multibyte (Qt);
 12545 
 12546       /* Raise the frame containing the echo area.  */
 12547       if (minibuffer_auto_raise)
 12548         {
 12549           struct frame *sf = SELECTED_FRAME ();
 12550           Lisp_Object mini_window;
 12551           mini_window = FRAME_MINIBUF_WINDOW (sf);
 12552           Fraise_frame  (WINDOW_FRAME (XWINDOW (mini_window)));
 12553         }
 12554 
 12555       message_log_maybe_newline ();
 12556       message_buf_print = true;
 12557     }
 12558   else
 12559     {
 12560       if (NILP (echo_area_buffer[0]))
 12561         {
 12562           if (EQ (echo_area_buffer[1], echo_buffer[0]))
 12563             echo_area_buffer[0] = echo_buffer[1];
 12564           else
 12565             echo_area_buffer[0] = echo_buffer[0];
 12566         }
 12567 
 12568       if (current_buffer != XBUFFER (echo_area_buffer[0]))
 12569         {
 12570           /* Someone switched buffers between print requests.  */
 12571           set_buffer_internal (XBUFFER (echo_area_buffer[0]));
 12572           bset_truncate_lines (current_buffer, Qnil);
 12573         }
 12574     }
 12575 }
 12576 
 12577 
 12578 /* Display an echo area message in window W.  Value is true if W's
 12579    height is changed.  If display_last_displayed_message_p,
 12580    display the message that was last displayed, otherwise
 12581    display the current message.  */
 12582 
 12583 static bool
 12584 display_echo_area (struct window *w)
 12585 {
 12586   bool no_message_p, window_height_changed_p;
 12587 
 12588   /* Temporarily disable garbage collections while displaying the echo
 12589      area.  This is done because a GC can print a message itself.
 12590      That message would modify the echo area buffer's contents while a
 12591      redisplay of the buffer is going on, and seriously confuse
 12592      redisplay.  */
 12593   specpdl_ref count = inhibit_garbage_collection ();
 12594 
 12595   /* If there is no message, we must call display_echo_area_1
 12596      nevertheless because it resizes the window.  But we will have to
 12597      reset the echo_area_buffer in question to nil at the end because
 12598      with_echo_area_buffer will set it to an empty buffer.  */
 12599   bool i = display_last_displayed_message_p;
 12600   /* According to the C standard, the integral value
 12601      of a "bool" is always 0 or 1, so this array access is safe here,
 12602      if oddly typed. */
 12603   no_message_p = NILP (echo_area_buffer[i]);
 12604 
 12605   window_height_changed_p
 12606     = with_echo_area_buffer (w, display_last_displayed_message_p,
 12607                              display_echo_area_1, w, Qnil);
 12608 
 12609   if (no_message_p)
 12610     echo_area_buffer[i] = Qnil;
 12611 
 12612   unbind_to (count, Qnil);
 12613   return window_height_changed_p;
 12614 }
 12615 
 12616 
 12617 /* Helper for display_echo_area.  Display the current buffer which
 12618    contains the current echo area message in window W, a mini-window,
 12619    a pointer to which is passed in A1.  A2 is currently not used.
 12620    Change the height of W so that all of the message is displayed.
 12621    Value is true if height of W was changed.  */
 12622 
 12623 static bool
 12624 display_echo_area_1 (void *a1, Lisp_Object a2)
 12625 {
 12626   struct window *w = a1;
 12627   Lisp_Object window;
 12628   struct text_pos start;
 12629 
 12630   /* We are about to enter redisplay without going through
 12631      redisplay_internal, so we need to forget these faces by hand
 12632      here.  */
 12633   forget_escape_and_glyphless_faces ();
 12634 
 12635   /* Do this before displaying, so that we have a large enough glyph
 12636      matrix for the display.  If we can't get enough space for the
 12637      whole text, display the last N lines.  That works by setting w->start.  */
 12638   bool window_height_changed_p = resize_mini_window (w, false);
 12639 
 12640   /* Use the starting position chosen by resize_mini_window.  */
 12641   SET_TEXT_POS_FROM_MARKER (start, w->start);
 12642 
 12643   /* Display.  */
 12644   clear_glyph_matrix (w->desired_matrix);
 12645   XSETWINDOW (window, w);
 12646   void *itdata = bidi_shelve_cache ();
 12647   try_window (window, start, 0);
 12648   bidi_unshelve_cache (itdata, false);
 12649 
 12650   return window_height_changed_p;
 12651 }
 12652 
 12653 
 12654 /* Resize the echo area window to exactly the size needed for the
 12655    currently displayed message, if there is one.  If a mini-buffer
 12656    is active, don't shrink it.  */
 12657 
 12658 void
 12659 resize_echo_area_exactly (void)
 12660 {
 12661   if (BUFFERP (echo_area_buffer[0])
 12662       && WINDOWP (echo_area_window))
 12663     {
 12664       struct window *w = XWINDOW (echo_area_window);
 12665       Lisp_Object resize_exactly = (minibuf_level == 0 ? Qt : Qnil);
 12666       bool resized_p = with_echo_area_buffer (w, 0, resize_mini_window_1,
 12667                                               w, resize_exactly);
 12668       if (resized_p)
 12669         {
 12670           windows_or_buffers_changed = 42;
 12671           update_mode_lines = 30;
 12672           redisplay_internal ();
 12673         }
 12674     }
 12675 }
 12676 
 12677 
 12678 /* Callback function for with_echo_area_buffer, when used from
 12679    resize_echo_area_exactly.  A1 contains a pointer to the window to
 12680    resize, EXACTLY non-nil means resize the mini-window exactly to the
 12681    size of the text displayed.  Value is what resize_mini_window
 12682    returns.  */
 12683 
 12684 static bool
 12685 resize_mini_window_1 (void *a1, Lisp_Object exactly)
 12686 {
 12687   return resize_mini_window (a1, !NILP (exactly));
 12688 }
 12689 
 12690 
 12691 /* Resize mini-window W to fit the size of its contents.  EXACT_P
 12692    means size the window exactly to the size needed.  Otherwise, it's
 12693    only enlarged until W's buffer is empty.
 12694 
 12695    Set W->start to the right place to begin display.  If the whole
 12696    contents fit, start at the beginning.  Otherwise, start so as
 12697    to make the end of the contents appear.  This is particularly
 12698    important for y-or-n-p, but seems desirable generally.
 12699 
 12700    Value is true if the window height has been changed.  */
 12701 
 12702 bool
 12703 resize_mini_window (struct window *w, bool exact_p)
 12704 {
 12705   struct frame *f = XFRAME (w->frame);
 12706   int old_height = WINDOW_BOX_TEXT_HEIGHT (w);
 12707 
 12708   eassert (MINI_WINDOW_P (w));
 12709 
 12710   /* Don't resize windows while redisplaying a window; it would
 12711      confuse redisplay functions when the size of the window they are
 12712      displaying changes from under them.  Such a resizing can happen,
 12713      for instance, when which-func prints a long message while
 12714      we are running fontification-functions.  We're running these
 12715      functions with safe_call which binds inhibit-redisplay to t.  */
 12716   if (!NILP (Vinhibit_redisplay))
 12717     return false;
 12718 
 12719   /* By default, start display at the beginning.  */
 12720   if (redisplay_adhoc_scroll_in_resize_mini_windows)
 12721     set_marker_both (w->start, w->contents,
 12722                      BUF_BEGV (XBUFFER (w->contents)),
 12723                      BUF_BEGV_BYTE (XBUFFER (w->contents)));
 12724 
 12725   /* Nil means don't try to resize.  */
 12726   if ((NILP (Vresize_mini_windows)
 12727        && (NILP (resize_mini_frames) || !FRAME_MINIBUF_ONLY_P (f)))
 12728       || (FRAME_X_P (f) && FRAME_OUTPUT_DATA (f) == NULL))
 12729     return false;
 12730 
 12731   if (FRAME_MINIBUF_ONLY_P (f))
 12732     {
 12733       if (!NILP (resize_mini_frames))
 12734         safe_call1 (Qwindow__resize_mini_frame, WINDOW_FRAME (w));
 12735     }
 12736   else
 12737     {
 12738       struct it it;
 12739       int unit = FRAME_LINE_HEIGHT (f);
 12740       int height, max_height;
 12741       struct text_pos start;
 12742       struct buffer *old_current_buffer = NULL;
 12743       int windows_height = FRAME_INNER_HEIGHT (f);
 12744 
 12745       if (current_buffer != XBUFFER (w->contents))
 12746         {
 12747           old_current_buffer = current_buffer;
 12748           set_buffer_internal (XBUFFER (w->contents));
 12749         }
 12750 
 12751       init_iterator (&it, w, BEGV, BEGV_BYTE, NULL, DEFAULT_FACE_ID);
 12752 
 12753       /* Compute the max. number of lines specified by the user.  */
 12754       if (FLOATP (Vmax_mini_window_height))
 12755         max_height = XFLOAT_DATA (Vmax_mini_window_height) * windows_height;
 12756       else if (FIXNUMP (Vmax_mini_window_height))
 12757         max_height = XFIXNUM (Vmax_mini_window_height) * unit;
 12758       else
 12759         max_height = windows_height / 4;
 12760 
 12761       /* Correct that max. height if it's bogus.  */
 12762       max_height = clip_to_bounds (unit, max_height, windows_height);
 12763 
 12764       /* Find out the height of the text in the window.  */
 12765       last_height = 0;
 12766       move_it_to (&it, ZV, -1, -1, -1, MOVE_TO_POS);
 12767       /* If move_it_to moved to the next visible line after EOB,
 12768          account for the height of the last full line.  */
 12769       if (it.max_ascent == 0 && it.max_descent == 0)
 12770         {
 12771           height = it.current_y;
 12772           /* Don't add the last line's height if lines are truncated
 12773              and the text doesn't end in a newline.
 12774              FIXME: if the text ends in a newline from a display
 12775              property or an overlay string, they lose: the mini-window
 12776              might not show the last empty line.  */
 12777           if (!(it.line_wrap == TRUNCATE
 12778                 && it.current_x <= it.first_visible_x
 12779                 && ZV_BYTE > 1
 12780                 && FETCH_BYTE (ZV_BYTE - 1) != '\n'))
 12781             height += last_height;
 12782         }
 12783       else
 12784         height = it.current_y + it.max_ascent + it.max_descent;
 12785       height -= min (it.extra_line_spacing, it.max_extra_line_spacing);
 12786 
 12787       /* Compute a suitable window start.  */
 12788       if (height > max_height)
 12789         {
 12790           height = (max_height / unit) * unit;
 12791           if (redisplay_adhoc_scroll_in_resize_mini_windows)
 12792             {
 12793               init_iterator (&it, w, ZV, ZV_BYTE, NULL, DEFAULT_FACE_ID);
 12794               move_it_vertically_backward (&it, height - unit);
 12795               /* The following move is usually a no-op when the stuff
 12796                  displayed in the mini-window comes entirely from buffer
 12797                  text, but it is needed when some of it comes from overlay
 12798                  strings, especially when there's an after-string at ZV.
 12799                  This happens with some completion packages, like
 12800                  icomplete, ido-vertical, etc.  With those packages, if we
 12801                  don't force w->start to be at the beginning of a screen
 12802                  line, important parts of the stuff in the mini-window,
 12803                  such as user prompt, will be hidden from view.  */
 12804               move_it_by_lines (&it, 0);
 12805               start = it.current.pos;
 12806               /* Prevent redisplay_window from recentering, and thus from
 12807                  overriding the window-start point we computed here.  */
 12808               w->start_at_line_beg = false;
 12809               SET_MARKER_FROM_TEXT_POS (w->start, start);
 12810             }
 12811         }
 12812       else
 12813         {
 12814           SET_TEXT_POS (start, BEGV, BEGV_BYTE);
 12815           SET_MARKER_FROM_TEXT_POS (w->start, start);
 12816         }
 12817 
 12818       if (EQ (Vresize_mini_windows, Qgrow_only))
 12819         {
 12820           /* Let it grow only, until we display an empty message, in which
 12821              case the window shrinks again.  */
 12822           if (height > old_height)
 12823             grow_mini_window (w, height - old_height);
 12824           else if (height < old_height && (exact_p || BEGV == ZV))
 12825             shrink_mini_window (w);
 12826         }
 12827       else if (height != old_height)
 12828         /* Always resize to exact size needed.  */
 12829         grow_mini_window (w, height - old_height);
 12830 
 12831       if (old_current_buffer)
 12832         set_buffer_internal (old_current_buffer);
 12833     }
 12834 
 12835   return WINDOW_BOX_TEXT_HEIGHT (w) != old_height;
 12836 }
 12837 
 12838 
 12839 /* Value is the current message, a string, or nil if there is no
 12840    current message.  */
 12841 
 12842 Lisp_Object
 12843 current_message (void)
 12844 {
 12845   Lisp_Object msg;
 12846 
 12847   if (!BUFFERP (echo_area_buffer[0]))
 12848     msg = Qnil;
 12849   else
 12850     {
 12851       with_echo_area_buffer (0, 0, current_message_1, &msg, Qnil);
 12852       if (NILP (msg))
 12853         echo_area_buffer[0] = Qnil;
 12854     }
 12855 
 12856   return msg;
 12857 }
 12858 
 12859 
 12860 static bool
 12861 current_message_1 (void *a1, Lisp_Object a2)
 12862 {
 12863   Lisp_Object *msg = a1;
 12864 
 12865   if (Z > BEG)
 12866     *msg = make_buffer_string (BEG, Z, true);
 12867   else
 12868     *msg = Qnil;
 12869   return false;
 12870 }
 12871 
 12872 
 12873 /* Push the current message on Vmessage_stack for later restoration
 12874    by restore_message.  Value is true if the current message isn't
 12875    empty.  This is a relatively infrequent operation, so it's not
 12876    worth optimizing.  */
 12877 
 12878 bool
 12879 push_message (void)
 12880 {
 12881   Lisp_Object msg = current_message ();
 12882   Vmessage_stack = Fcons (msg, Vmessage_stack);
 12883   return STRINGP (msg);
 12884 }
 12885 
 12886 
 12887 /* Restore message display from the top of Vmessage_stack.  */
 12888 
 12889 void
 12890 restore_message (void)
 12891 {
 12892   eassert (CONSP (Vmessage_stack));
 12893   message3_nolog (XCAR (Vmessage_stack));
 12894 }
 12895 
 12896 
 12897 /* Handler for unwind-protect calling pop_message.  */
 12898 
 12899 void
 12900 pop_message_unwind (void)
 12901 {
 12902   /* Pop the top-most entry off Vmessage_stack.  */
 12903   eassert (CONSP (Vmessage_stack));
 12904   Vmessage_stack = XCDR (Vmessage_stack);
 12905 }
 12906 
 12907 
 12908 /* Check that Vmessage_stack is nil.  Called from emacs.c when Emacs
 12909    exits.  If the stack is not empty, we have a missing
 12910    pop_message_unwind somewhere.  */
 12911 
 12912 void
 12913 check_message_stack (void)
 12914 {
 12915   if (!NILP (Vmessage_stack))
 12916     emacs_abort ();
 12917 }
 12918 
 12919 void
 12920 clear_message_stack (void)
 12921 {
 12922   Vmessage_stack = Qnil;
 12923 }
 12924 
 12925 /* Truncate to NCHARS what will be displayed in the echo area the next
 12926    time we display it---but don't redisplay it now.  */
 12927 
 12928 void
 12929 truncate_echo_area (ptrdiff_t nchars)
 12930 {
 12931   if (nchars == 0)
 12932     echo_area_buffer[0] = Qnil;
 12933   else if (!noninteractive
 12934            && INTERACTIVE
 12935            && !NILP (echo_area_buffer[0]))
 12936     {
 12937       struct frame *sf = SELECTED_FRAME ();
 12938       /* Error messages get reported properly by cmd_error, so this must be
 12939          just an informative message; if the frame hasn't really been
 12940          initialized yet, just toss it.  */
 12941       if (sf->glyphs_initialized_p)
 12942         with_echo_area_buffer (0, 0, truncate_message_1,
 12943                                (void *) (intptr_t) nchars, Qnil);
 12944     }
 12945 }
 12946 
 12947 
 12948 /* Helper function for truncate_echo_area.  Truncate the current
 12949    message to at most NCHARS characters.  */
 12950 
 12951 static bool
 12952 truncate_message_1 (void *a1, Lisp_Object a2)
 12953 {
 12954   intptr_t nchars = (intptr_t) a1;
 12955   if (BEG + nchars < Z)
 12956     del_range (BEG + nchars, Z);
 12957   if (Z == BEG)
 12958     echo_area_buffer[0] = Qnil;
 12959   return false;
 12960 }
 12961 
 12962 extern intptr_t garbage_collection_inhibited;
 12963 
 12964 /* Set the current message to STRING.  */
 12965 
 12966 static void
 12967 set_message (Lisp_Object string)
 12968 {
 12969   Lisp_Object message = Qnil;
 12970 
 12971   eassert (STRINGP (string));
 12972 
 12973   if (FUNCTIONP (Vset_message_function)
 12974       /* FIXME: (bug#63253) We should really make the regexp engine re-entrant,
 12975          but in the mean time, let's ignore `set-message-function` when
 12976          called from `probably_quit`.  */
 12977       && !garbage_collection_inhibited)
 12978     {
 12979       specpdl_ref count = SPECPDL_INDEX ();
 12980       specbind (Qinhibit_quit, Qt);
 12981       message = safe_call1 (Vset_message_function, string);
 12982       unbind_to (count, Qnil);
 12983 
 12984       if (STRINGP (message))
 12985         {
 12986           string = message;
 12987           message = Qnil;
 12988         }
 12989     }
 12990 
 12991   if (NILP (message))
 12992     {
 12993       message_enable_multibyte = STRING_MULTIBYTE (string);
 12994 
 12995       with_echo_area_buffer (0, -1, set_message_1, 0, string);
 12996       message_buf_print = false;
 12997       help_echo_showing_p = false;
 12998     }
 12999 
 13000   if (STRINGP (Vdebug_on_message)
 13001       && STRINGP (string)
 13002       && fast_string_match (Vdebug_on_message, string) >= 0)
 13003     call_debugger (list2 (Qerror, string));
 13004 }
 13005 
 13006 
 13007 /* Helper function for set_message.  First argument is ignored and second
 13008    argument has the same meaning as for set_message.
 13009    This function is called with the echo area buffer being current.  */
 13010 
 13011 static bool
 13012 set_message_1 (void *a1, Lisp_Object string)
 13013 {
 13014   eassert (STRINGP (string));
 13015 
 13016   /* Change multibyteness of the echo buffer appropriately.  We always
 13017      set it to be multibyte, except when
 13018      unibyte-display-via-language-environment is non-nil and the
 13019      string to display is unibyte, because in that case unibyte
 13020      characters should not be displayed as octal escapes.  */
 13021   if (!message_enable_multibyte
 13022       && unibyte_display_via_language_environment
 13023       && !NILP (BVAR (current_buffer, enable_multibyte_characters)))
 13024     Fset_buffer_multibyte (Qnil);
 13025   else if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
 13026     Fset_buffer_multibyte (Qt);
 13027 
 13028   bset_truncate_lines (current_buffer, message_truncate_lines ? Qt : Qnil);
 13029   if (!NILP (BVAR (current_buffer, bidi_display_reordering)))
 13030     bset_bidi_paragraph_direction (current_buffer, Qleft_to_right);
 13031 
 13032   /* Insert new message at BEG.  */
 13033   TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
 13034 
 13035   /* This function takes care of single/multibyte conversion.
 13036      We just have to ensure that the echo area buffer has the right
 13037      setting of enable_multibyte_characters.  */
 13038   insert_from_string (string, 0, 0, SCHARS (string), SBYTES (string), true);
 13039 
 13040   return false;
 13041 }
 13042 
 13043 
 13044 /* Clear messages.  CURRENT_P means clear the current message.
 13045    LAST_DISPLAYED_P means clear the message last displayed.  */
 13046 
 13047 void
 13048 clear_message (bool current_p, bool last_displayed_p)
 13049 {
 13050   Lisp_Object preserve = Qnil;
 13051 
 13052   if (current_p)
 13053     {
 13054       if (FUNCTIONP (Vclear_message_function)
 13055           /* FIXME: (bug#63253) Same as for `set-message-function` above.  */
 13056           && !garbage_collection_inhibited)
 13057         {
 13058           specpdl_ref count = SPECPDL_INDEX ();
 13059           specbind (Qinhibit_quit, Qt);
 13060           preserve = safe_call (1, Vclear_message_function);
 13061           unbind_to (count, Qnil);
 13062         }
 13063 
 13064       if (!EQ (preserve, Qdont_clear_message))
 13065         {
 13066           echo_area_buffer[0] = Qnil;
 13067           message_cleared_p = true;
 13068         }
 13069     }
 13070 
 13071   if (last_displayed_p)
 13072     echo_area_buffer[1] = Qnil;
 13073 
 13074   message_buf_print = false;
 13075 }
 13076 
 13077 /* Clear garbaged frames.
 13078 
 13079    This function is used where the old redisplay called
 13080    redraw_garbaged_frames which in turn called redraw_frame which in
 13081    turn called clear_frame.  The call to clear_frame was a source of
 13082    flickering.  I believe a clear_frame is not necessary.  It should
 13083    suffice in the new redisplay to invalidate all current matrices,
 13084    and ensure a complete redisplay of all windows.  */
 13085 
 13086 static void
 13087 clear_garbaged_frames (void)
 13088 {
 13089   if (frame_garbaged)
 13090     {
 13091       Lisp_Object tail, frame;
 13092       struct frame *sf = SELECTED_FRAME ();
 13093 
 13094       FOR_EACH_FRAME (tail, frame)
 13095         {
 13096           struct frame *f = XFRAME (frame);
 13097 
 13098           if (FRAME_REDISPLAY_P (f) && FRAME_GARBAGED_P (f))
 13099             {
 13100               if (f->resized_p
 13101                   /* It makes no sense to redraw a non-selected TTY
 13102                      frame, since that will actually clear the
 13103                      selected frame, and might leave the selected
 13104                      frame with corrupted display, if it happens not
 13105                      to be marked garbaged.  */
 13106                   && !(f != sf && (FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))))
 13107                 redraw_frame (f);
 13108               else
 13109                 clear_current_matrices (f);
 13110 
 13111 #ifdef HAVE_WINDOW_SYSTEM
 13112               if (FRAME_WINDOW_P (f)
 13113                   && FRAME_RIF (f)->clear_under_internal_border)
 13114                 FRAME_RIF (f)->clear_under_internal_border (f);
 13115 #endif
 13116               fset_redisplay (f);
 13117               f->garbaged = false;
 13118               f->resized_p = false;
 13119             }
 13120         }
 13121 
 13122       frame_garbaged = false;
 13123     }
 13124 }
 13125 
 13126 
 13127 /* Redisplay the echo area of the selected frame.  If UPDATE_FRAME_P, update
 13128    selected_frame.  */
 13129 
 13130 static void
 13131 echo_area_display (bool update_frame_p)
 13132 {
 13133   Lisp_Object mini_window;
 13134   struct window *w;
 13135   struct frame *f;
 13136   bool window_height_changed_p = false;
 13137   struct frame *sf = SELECTED_FRAME ();
 13138 
 13139   mini_window = FRAME_MINIBUF_WINDOW (sf);
 13140   if (NILP (mini_window))
 13141     return;
 13142 
 13143   w = XWINDOW (mini_window);
 13144   f = XFRAME (WINDOW_FRAME (w));
 13145 
 13146   /* Don't display if frame is invisible or not yet initialized.  */
 13147   if (!FRAME_REDISPLAY_P (f) || !f->glyphs_initialized_p)
 13148     return;
 13149 
 13150 #ifdef HAVE_WINDOW_SYSTEM
 13151   /* When Emacs starts, selected_frame may be the initial terminal
 13152      frame.  If we let this through, a message would be displayed on
 13153      the terminal.  */
 13154   if (FRAME_INITIAL_P (XFRAME (selected_frame)))
 13155     return;
 13156 #endif /* HAVE_WINDOW_SYSTEM */
 13157 
 13158   /* Redraw garbaged frames.  */
 13159   clear_garbaged_frames ();
 13160 
 13161   if (!NILP (echo_area_buffer[0]) || minibuf_level == 0)
 13162     {
 13163       echo_area_window = mini_window;
 13164       window_height_changed_p = display_echo_area (w);
 13165       w->must_be_updated_p = true;
 13166 
 13167       /* Update the display, unless called from redisplay_internal.
 13168          Also don't update the screen during redisplay itself.  The
 13169          update will happen at the end of redisplay, and an update
 13170          here could cause confusion.  */
 13171       if (update_frame_p && !redisplaying_p)
 13172         {
 13173           int n = 0;
 13174 
 13175           /* If the display update has been interrupted by pending
 13176              input, update mode lines in the frame.  Due to the
 13177              pending input, it might have been that redisplay hasn't
 13178              been called, so that mode lines above the echo area are
 13179              garbaged.  This looks odd, so we prevent it here.  */
 13180           if (!display_completed)
 13181             {
 13182               n = redisplay_mode_lines (FRAME_ROOT_WINDOW (f), false);
 13183 
 13184 #ifdef HAVE_WINDOW_SYSTEM
 13185               if (FRAME_WINDOW_P (f)
 13186                   && FRAME_RIF (f)->clear_under_internal_border)
 13187                 FRAME_RIF (f)->clear_under_internal_border (f);
 13188 #endif
 13189             }
 13190 
 13191           if (window_height_changed_p
 13192               /* Don't do this if Emacs is shutting down.  Redisplay
 13193                  needs to run hooks.  */
 13194               && !NILP (Vrun_hooks))
 13195             {
 13196               /* Must update other windows.  Likewise as in other
 13197                  cases, don't let this update be interrupted by
 13198                  pending input.  */
 13199               specpdl_ref count = SPECPDL_INDEX ();
 13200               specbind (Qredisplay_dont_pause, Qt);
 13201               fset_redisplay (f);
 13202               redisplay_internal ();
 13203               unbind_to (count, Qnil);
 13204             }
 13205           else if (FRAME_WINDOW_P (f) && n == 0)
 13206             {
 13207               /* Window configuration is the same as before.
 13208                  Can do with a display update of the echo area,
 13209                  unless we displayed some mode lines.  */
 13210               update_single_window (w);
 13211               flush_frame (f);
 13212             }
 13213           else
 13214             update_frame (f, true, true);
 13215 
 13216           /* If cursor is in the echo area, make sure that the next
 13217              redisplay displays the minibuffer, so that the cursor will
 13218              be replaced with what the minibuffer wants.  */
 13219           if (cursor_in_echo_area)
 13220             wset_redisplay (XWINDOW (mini_window));
 13221         }
 13222     }
 13223   else if (!EQ (mini_window, selected_window))
 13224     wset_redisplay (XWINDOW (mini_window));
 13225 
 13226   /* Last displayed message is now the current message.  */
 13227   echo_area_buffer[1] = echo_area_buffer[0];
 13228   /* Inform read_char that we're not echoing.  */
 13229   echo_message_buffer = Qnil;
 13230 
 13231   /* Prevent redisplay optimization in redisplay_internal by resetting
 13232      this_line_start_pos.  This is done because the mini-buffer now
 13233      displays the message instead of its buffer text.  */
 13234   if (EQ (mini_window, selected_window))
 13235     CHARPOS (this_line_start_pos) = 0;
 13236 
 13237   if (window_height_changed_p)
 13238     {
 13239       fset_redisplay (f);
 13240 
 13241       /* If window configuration was changed, frames may have been
 13242          marked garbaged.  Clear them or we will experience
 13243          surprises wrt scrolling.
 13244          FIXME: How/why/when?  */
 13245       clear_garbaged_frames ();
 13246     }
 13247 }
 13248 
 13249 /* True if W's buffer was changed but not saved.  */
 13250 
 13251 static bool
 13252 window_buffer_changed (struct window *w)
 13253 {
 13254   struct buffer *b = XBUFFER (w->contents);
 13255 
 13256   eassert (BUFFER_LIVE_P (b));
 13257 
 13258   return (BUF_SAVE_MODIFF (b) < BUF_MODIFF (b)) != w->last_had_star;
 13259 }
 13260 
 13261 /* True if W has %c or %C in its mode line and mode line should be updated.  */
 13262 
 13263 static bool
 13264 mode_line_update_needed (struct window *w)
 13265 {
 13266   return (w->column_number_displayed != -1
 13267           && !(PT == w->last_point && !window_outdated (w))
 13268           && (w->column_number_displayed != current_column ()));
 13269 }
 13270 
 13271 /* True if window start of W is frozen and may not be changed during
 13272    redisplay.  */
 13273 
 13274 static bool
 13275 window_frozen_p (struct window *w)
 13276 {
 13277   if (FRAME_WINDOWS_FROZEN (XFRAME (WINDOW_FRAME (w))))
 13278     {
 13279       Lisp_Object window;
 13280 
 13281       XSETWINDOW (window, w);
 13282       if (MINI_WINDOW_P (w))
 13283         return false;
 13284       else if (EQ (window, selected_window))
 13285         return false;
 13286       else if (MINI_WINDOW_P (XWINDOW (selected_window))
 13287                && EQ (window, Vminibuf_scroll_window))
 13288         /* This special window can't be frozen too.  */
 13289         return false;
 13290       else
 13291         return true;
 13292     }
 13293   return false;
 13294 }
 13295 
 13296 /***********************************************************************
 13297                      Mode Lines and Frame Titles
 13298  ***********************************************************************/
 13299 
 13300 /* A buffer for constructing non-propertized mode-line strings and
 13301    frame titles in it; allocated from the heap in init_xdisp and
 13302    resized as needed in store_mode_line_noprop_char.  */
 13303 
 13304 static char *mode_line_noprop_buf;
 13305 
 13306 /* The buffer's end, and a current output position in it.  */
 13307 
 13308 static char *mode_line_noprop_buf_end;
 13309 static char *mode_line_noprop_ptr;
 13310 
 13311 #define MODE_LINE_NOPROP_LEN(start) \
 13312   ((mode_line_noprop_ptr - mode_line_noprop_buf) - start)
 13313 
 13314 static enum {
 13315   MODE_LINE_DISPLAY = 0,
 13316   MODE_LINE_TITLE,
 13317   MODE_LINE_NOPROP,
 13318   MODE_LINE_STRING
 13319 } mode_line_target;
 13320 
 13321 /* Alist that caches the results of :propertize.
 13322    Each element is (PROPERTIZED-STRING . PROPERTY-LIST).  */
 13323 static Lisp_Object mode_line_proptrans_alist;
 13324 
 13325 /* List of strings making up the mode-line.  */
 13326 static Lisp_Object mode_line_string_list;
 13327 
 13328 /* Base face property when building propertized mode line string.  */
 13329 static Lisp_Object mode_line_string_face;
 13330 static Lisp_Object mode_line_string_face_prop;
 13331 
 13332 
 13333 /* Unwind data for mode line strings */
 13334 
 13335 static Lisp_Object Vmode_line_unwind_vector;
 13336 
 13337 static Lisp_Object
 13338 format_mode_line_unwind_data (struct frame *target_frame,
 13339                               struct buffer *obuf,
 13340                               Lisp_Object owin,
 13341                               bool save_proptrans)
 13342 {
 13343   Lisp_Object vector, tmp;
 13344 
 13345   /* Reduce consing by keeping one vector in
 13346      Vwith_echo_area_save_vector.  */
 13347   vector = Vmode_line_unwind_vector;
 13348   Vmode_line_unwind_vector = Qnil;
 13349 
 13350   if (NILP (vector))
 13351     vector = make_nil_vector (12);
 13352 
 13353   ASET (vector, 0, make_fixnum (mode_line_target));
 13354   ASET (vector, 1, make_fixnum (MODE_LINE_NOPROP_LEN (0)));
 13355   ASET (vector, 2, mode_line_string_list);
 13356   ASET (vector, 3, save_proptrans ? mode_line_proptrans_alist : Qt);
 13357   ASET (vector, 4, mode_line_string_face);
 13358   ASET (vector, 5, mode_line_string_face_prop);
 13359 
 13360   if (obuf)
 13361     XSETBUFFER (tmp, obuf);
 13362   else
 13363     tmp = Qnil;
 13364   ASET (vector, 6, tmp);
 13365   ASET (vector, 7, owin);
 13366   if (target_frame)
 13367     {
 13368       Lisp_Object buffer = XWINDOW (target_frame->selected_window)->contents;
 13369       struct buffer *b = XBUFFER (buffer);
 13370       struct buffer *cb = current_buffer;
 13371 
 13372       /* Similarly to `with-selected-window', if the operation selects
 13373          a window on another frame, we must restore that frame's
 13374          selected window, and (for a tty) the top-frame.  */
 13375       ASET (vector, 8, target_frame->selected_window);
 13376       if (FRAME_TERMCAP_P (target_frame))
 13377         ASET (vector, 9, FRAME_TTY (target_frame)->top_frame);
 13378 
 13379       /* If we select a window on another frame, make sure that that
 13380          selection does not leave its buffer's point modified when
 13381          unwinding (Bug#32777).  */
 13382       ASET (vector, 10, buffer);
 13383       current_buffer = b;
 13384       ASET (vector, 11, build_marker (current_buffer, PT, PT_BYTE));
 13385       current_buffer = cb;
 13386     }
 13387 
 13388   return vector;
 13389 }
 13390 
 13391 static void
 13392 unwind_format_mode_line (Lisp_Object vector)
 13393 {
 13394   Lisp_Object old_window = AREF (vector, 7);
 13395   Lisp_Object target_frame_window = AREF (vector, 8);
 13396   Lisp_Object old_top_frame = AREF (vector, 9);
 13397 
 13398   mode_line_target = XFIXNUM (AREF (vector, 0));
 13399   mode_line_noprop_ptr = mode_line_noprop_buf + XFIXNUM (AREF (vector, 1));
 13400   mode_line_string_list = AREF (vector, 2);
 13401   if (! EQ (AREF (vector, 3), Qt))
 13402     mode_line_proptrans_alist = AREF (vector, 3);
 13403   mode_line_string_face = AREF (vector, 4);
 13404   mode_line_string_face_prop = AREF (vector, 5);
 13405 
 13406   /* Select window before buffer, since it may change the buffer.  */
 13407   if (WINDOW_LIVE_P (old_window))
 13408     {
 13409       /* If the operation that we are unwinding had selected a window
 13410          on a different frame, reset its frame-selected-window.  For a
 13411          text terminal, reset its top-frame if necessary.  */
 13412       if (WINDOW_LIVE_P (target_frame_window))
 13413         {
 13414           Lisp_Object frame
 13415             = WINDOW_FRAME (XWINDOW (target_frame_window));
 13416 
 13417           if (!EQ (frame, WINDOW_FRAME (XWINDOW (old_window))))
 13418             Fselect_window (target_frame_window, Qt);
 13419 
 13420           if (!NILP (old_top_frame) && !EQ (old_top_frame, frame)
 13421               /* This could've been destroyed during the formatting,
 13422                  possibly because the terminal was deleted.  */
 13423               && FRAME_LIVE_P (XFRAME (old_top_frame)))
 13424             Fselect_frame (old_top_frame, Qt);
 13425         }
 13426 
 13427       Fselect_window (old_window, Qt);
 13428 
 13429       /* Restore point of target_frame_window's buffer (Bug#32777).
 13430          But do this only after old_window has been reselected to
 13431          avoid that the window point of target_frame_window moves.  */
 13432       if (WINDOW_LIVE_P (target_frame_window))
 13433         {
 13434           Lisp_Object buffer = AREF (vector, 10);
 13435 
 13436           if (BUFFER_LIVE_P (XBUFFER (buffer)))
 13437             {
 13438               struct buffer *cb = current_buffer;
 13439 
 13440               current_buffer = XBUFFER (buffer);
 13441               set_point_from_marker (AREF (vector, 11));
 13442               ASET (vector, 11, Qnil);
 13443               current_buffer = cb;
 13444             }
 13445         }
 13446     }
 13447 
 13448   if (!NILP (AREF (vector, 6)))
 13449     {
 13450       set_buffer_internal_1 (XBUFFER (AREF (vector, 6)));
 13451       ASET (vector, 6, Qnil);
 13452     }
 13453 
 13454   Vmode_line_unwind_vector = vector;
 13455 }
 13456 
 13457 
 13458 /* Store a single character C for the frame title in mode_line_noprop_buf.
 13459    Re-allocate mode_line_noprop_buf if necessary.  */
 13460 
 13461 static void
 13462 store_mode_line_noprop_char (char c)
 13463 {
 13464   /* If output position has reached the end of the allocated buffer,
 13465      increase the buffer's size.  */
 13466   if (mode_line_noprop_ptr == mode_line_noprop_buf_end)
 13467     {
 13468       ptrdiff_t len = MODE_LINE_NOPROP_LEN (0);
 13469       ptrdiff_t size = len;
 13470       mode_line_noprop_buf =
 13471         xpalloc (mode_line_noprop_buf, &size, 1, STRING_BYTES_BOUND, 1);
 13472       mode_line_noprop_buf_end = mode_line_noprop_buf + size;
 13473       mode_line_noprop_ptr = mode_line_noprop_buf + len;
 13474     }
 13475 
 13476   *mode_line_noprop_ptr++ = c;
 13477 }
 13478 
 13479 
 13480 /* Store part of a frame title in mode_line_noprop_buf, beginning at
 13481    mode_line_noprop_ptr.  STRING is the string to store.  Do not copy
 13482    characters that yield more columns than PRECISION; PRECISION <= 0
 13483    means copy the whole string.  Pad with spaces until FIELD_WIDTH
 13484    number of characters have been copied; FIELD_WIDTH <= 0 means don't
 13485    pad.  Called from display_mode_element when it is used to build a
 13486    frame title.  */
 13487 
 13488 static int
 13489 store_mode_line_noprop (const char *string, int field_width, int precision)
 13490 {
 13491   const unsigned char *str = (const unsigned char *) string;
 13492   int n = 0;
 13493   ptrdiff_t dummy, nbytes;
 13494 
 13495   /* Copy at most PRECISION chars from STR.  */
 13496   nbytes = strlen (string);
 13497   n += c_string_width (str, nbytes, precision, &dummy, &nbytes);
 13498   while (nbytes--)
 13499     store_mode_line_noprop_char (*str++);
 13500 
 13501   /* Fill up with spaces until FIELD_WIDTH reached.  */
 13502   while (field_width > 0
 13503          && n < field_width)
 13504     {
 13505       store_mode_line_noprop_char (' ');
 13506       ++n;
 13507     }
 13508 
 13509   return n;
 13510 }
 13511 
 13512 /***********************************************************************
 13513                              Frame Titles
 13514  ***********************************************************************/
 13515 
 13516 #ifdef HAVE_WINDOW_SYSTEM
 13517 
 13518 /* Set the title of FRAME, if it has changed.  The title format is
 13519    Vicon_title_format if FRAME is iconified, otherwise it is
 13520    frame_title_format.  */
 13521 
 13522 void
 13523 gui_consider_frame_title (Lisp_Object frame)
 13524 {
 13525   struct frame *f = XFRAME (frame);
 13526   Lisp_Object format_data;
 13527 
 13528   if ((FRAME_WINDOW_P (f)
 13529        || FRAME_MINIBUF_ONLY_P (f)
 13530        || f->explicit_name)
 13531       && !FRAME_TOOLTIP_P (f))
 13532     {
 13533       /* Do we have more than one visible frame on this X display?  */
 13534       Lisp_Object tail, other_frame, fmt;
 13535       ptrdiff_t title_start;
 13536       char *title;
 13537       ptrdiff_t len;
 13538       struct it it;
 13539       specpdl_ref count = SPECPDL_INDEX ();
 13540 
 13541       FOR_EACH_FRAME (tail, other_frame)
 13542         {
 13543           struct frame *tf = XFRAME (other_frame);
 13544 
 13545           if (tf != f
 13546               && FRAME_KBOARD (tf) == FRAME_KBOARD (f)
 13547               && !FRAME_MINIBUF_ONLY_P (tf)
 13548               && !FRAME_PARENT_FRAME (tf)
 13549               && !FRAME_TOOLTIP_P (tf)
 13550               && (FRAME_VISIBLE_P (tf) || FRAME_ICONIFIED_P (tf)))
 13551             break;
 13552         }
 13553 
 13554       /* Set global variable indicating that multiple frames exist.  */
 13555       multiple_frames = CONSP (tail);
 13556 
 13557       /* select-frame calls resize_mini_window, which could resize the
 13558          mini-window and by that undo the effect of this redisplay
 13559          cycle wrt minibuffer and echo-area display.  Binding
 13560          inhibit-redisplay to t makes the call to resize_mini_window a
 13561          no-op, thus avoiding the adverse side effects.  */
 13562 
 13563       /* The following was moved before the record_unwind_protect form
 13564          below to inhibit redisplay also when restoring the selected
 13565          window/frame: This avoids that resize_mini_window sizes back
 13566          the minibuffer window of a temporarily selected frame.  See
 13567          Bug#34317.  */
 13568       specbind (Qinhibit_redisplay, Qt);
 13569 
 13570       /* Switch to the buffer of selected window of the frame.  Set up
 13571          mode_line_target so that display_mode_element will output
 13572          into mode_line_noprop_buf; then display the title.  Save the
 13573          original frame and selected window, and possibly the topmost
 13574          frame of the tty (for tty frames) into a vector; it will be
 13575          restored later.  */
 13576 
 13577       format_data = format_mode_line_unwind_data (f, current_buffer,
 13578                                                   selected_window,
 13579                                                   false);
 13580       record_unwind_protect (unwind_format_mode_line, format_data);
 13581 
 13582       Fselect_window (f->selected_window, Qt);
 13583       set_buffer_internal_1 (XBUFFER (XWINDOW (f->selected_window)->contents));
 13584       fmt = (FRAME_ICONIFIED_P (f) && !EQ (Vicon_title_format, Qt)
 13585              ? Vicon_title_format : Vframe_title_format);
 13586 
 13587       mode_line_target = MODE_LINE_TITLE;
 13588       title_start = MODE_LINE_NOPROP_LEN (0);
 13589       init_iterator (&it, XWINDOW (f->selected_window), -1, -1,
 13590                      NULL, DEFAULT_FACE_ID);
 13591       display_mode_element (&it, 0, -1, -1, fmt, Qnil, false);
 13592       len = MODE_LINE_NOPROP_LEN (title_start);
 13593       title = mode_line_noprop_buf + title_start;
 13594       /* Make sure that any raw bytes in the title are properly
 13595          represented by their multibyte sequences.  */
 13596       ptrdiff_t nchars = 0;
 13597       len = str_as_multibyte ((unsigned char *) title,
 13598                               mode_line_noprop_buf_end - title,
 13599                               len, &nchars);
 13600       unbind_to (count, Qnil);
 13601 
 13602       /* Set the title only if it's changed.  This avoids consing in
 13603          the common case where it hasn't.  (If it turns out that we've
 13604          already wasted too much time by walking through the list with
 13605          display_mode_element, then we might need to optimize at a
 13606          higher level than this.)  */
 13607       if ((! STRINGP (f->name)
 13608            || SBYTES (f->name) != len
 13609            || memcmp (title, SDATA (f->name), len) != 0)
 13610           && FRAME_TERMINAL (f)->implicit_set_name_hook)
 13611         {
 13612           Lisp_Object title_string = make_multibyte_string (title, nchars, len);
 13613           FRAME_TERMINAL (f)->implicit_set_name_hook (f, title_string, Qnil);
 13614         }
 13615     }
 13616 }
 13617 
 13618 #endif /* not HAVE_WINDOW_SYSTEM */
 13619 
 13620 
 13621 /***********************************************************************
 13622                               Menu Bars
 13623  ***********************************************************************/
 13624 
 13625 /* True if we will not redisplay all visible windows.  */
 13626 #define REDISPLAY_SOME_P()                              \
 13627   ((windows_or_buffers_changed == 0                     \
 13628     || windows_or_buffers_changed == REDISPLAY_SOME)    \
 13629    && (update_mode_lines == 0                           \
 13630        || update_mode_lines == REDISPLAY_SOME))
 13631 
 13632 static bool
 13633 needs_no_redisplay (struct window *w)
 13634 {
 13635   struct buffer *buffer = XBUFFER (w->contents);
 13636   struct frame *f = XFRAME (w->frame);
 13637   return (REDISPLAY_SOME_P ()
 13638           && !w->redisplay
 13639           && !w->update_mode_line
 13640           && !f->face_change
 13641           && !f->redisplay
 13642           && !buffer->text->redisplay
 13643           && window_point (w) == w->last_point);
 13644 }
 13645 
 13646 /* Prepare for redisplay by updating menu-bar item lists when
 13647    appropriate.  This can call eval.  */
 13648 
 13649 static void
 13650 prepare_menu_bars (void)
 13651 {
 13652   bool all_windows = windows_or_buffers_changed || update_mode_lines;
 13653   bool some_windows = REDISPLAY_SOME_P ();
 13654 
 13655   if (FUNCTIONP (Vpre_redisplay_function))
 13656     {
 13657       Lisp_Object windows = all_windows ? Qt : Qnil;
 13658       if (all_windows && some_windows)
 13659         {
 13660           Lisp_Object ws = window_list ();
 13661           for (windows = Qnil; CONSP (ws); ws = XCDR (ws))
 13662             {
 13663               Lisp_Object this = XCAR (ws);
 13664               struct window *w = XWINDOW (this);
 13665               /* Cf. conditions for redisplaying a window at the
 13666                  beginning of redisplay_window.  */
 13667               if (!needs_no_redisplay (w))
 13668                 windows = Fcons (this, windows);
 13669             }
 13670         }
 13671       safe__call1 (true, Vpre_redisplay_function, windows);
 13672     }
 13673 
 13674   /* Update all frame titles based on their buffer names, etc.  We do
 13675      this before the menu bars so that the buffer-menu will show the
 13676      up-to-date frame titles.  */
 13677 #ifdef HAVE_WINDOW_SYSTEM
 13678   if (all_windows)
 13679     {
 13680       Lisp_Object tail, frame;
 13681 
 13682       FOR_EACH_FRAME (tail, frame)
 13683         {
 13684           struct frame *f = XFRAME (frame);
 13685           struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
 13686           if (some_windows
 13687               && !f->redisplay
 13688               && !w->redisplay
 13689               && !XBUFFER (w->contents)->text->redisplay)
 13690             continue;
 13691 
 13692           if (!FRAME_TOOLTIP_P (f)
 13693               && (FRAME_ICONIFIED_P (f)
 13694                   || FRAME_VISIBLE_P (f) == 1
 13695                   /* Exclude TTY frames that are obscured because they
 13696                      are not the top frame on their console.  This is
 13697                      because gui_consider_frame_title actually switches
 13698                      to the frame, which for TTY frames means it is
 13699                      marked as garbaged, and will be completely
 13700                      redrawn on the next redisplay cycle.  This causes
 13701                      TTY frames to be completely redrawn, when there
 13702                      are more than one of them, even though nothing
 13703                      should be changed on display.  */
 13704                   || (FRAME_REDISPLAY_P (f) && FRAME_WINDOW_P (f))))
 13705             gui_consider_frame_title (frame);
 13706         }
 13707     }
 13708 #endif /* HAVE_WINDOW_SYSTEM */
 13709 
 13710   /* Update the menu bar item lists, if appropriate.  This has to be
 13711      done before any actual redisplay or generation of display lines.  */
 13712 
 13713   if (all_windows)
 13714     {
 13715       Lisp_Object tail, frame;
 13716       specpdl_ref count = SPECPDL_INDEX ();
 13717       /* True means that update_menu_bar has run its hooks
 13718          so any further calls to update_menu_bar shouldn't do so again.  */
 13719       bool menu_bar_hooks_run = false;
 13720 
 13721       record_unwind_save_match_data ();
 13722 
 13723       FOR_EACH_FRAME (tail, frame)
 13724         {
 13725           struct frame *f = XFRAME (frame);
 13726           struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
 13727 
 13728           /* Ignore tooltip frame.  */
 13729           if (FRAME_TOOLTIP_P (f))
 13730             continue;
 13731 
 13732           if (some_windows
 13733               && !f->redisplay
 13734               && !w->redisplay
 13735               && !XBUFFER (w->contents)->text->redisplay)
 13736             continue;
 13737 
 13738           if (!FRAME_PARENT_FRAME (f))
 13739             menu_bar_hooks_run = update_menu_bar (f, false, menu_bar_hooks_run);
 13740 
 13741           update_tab_bar (f, false);
 13742 #ifdef HAVE_WINDOW_SYSTEM
 13743           update_tool_bar (f, false);
 13744 #endif
 13745         }
 13746 
 13747       unbind_to (count, Qnil);
 13748     }
 13749   else
 13750     {
 13751       struct frame *sf = SELECTED_FRAME ();
 13752 
 13753       if (!FRAME_PARENT_FRAME (sf))
 13754         update_menu_bar (sf, true, false);
 13755 
 13756       update_tab_bar (sf, true);
 13757 #ifdef HAVE_WINDOW_SYSTEM
 13758       update_tool_bar (sf, true);
 13759 #endif
 13760     }
 13761 }
 13762 
 13763 
 13764 /* Update the menu bar item list for frame F.  This has to be done
 13765    before we start to fill in any display lines, because it can call
 13766    eval.
 13767 
 13768    If SAVE_MATCH_DATA, we must save and restore it here.
 13769 
 13770    If HOOKS_RUN, a previous call to update_menu_bar
 13771    already ran the menu bar hooks for this redisplay, so there
 13772    is no need to run them again.  The return value is the
 13773    updated value of this flag, to pass to the next call.  */
 13774 
 13775 static bool
 13776 update_menu_bar (struct frame *f, bool save_match_data, bool hooks_run)
 13777 {
 13778   Lisp_Object window;
 13779   struct window *w;
 13780 
 13781   /* If called recursively during a menu update, do nothing.  This can
 13782      happen when, for instance, an activate-menubar-hook causes a
 13783      redisplay.  */
 13784   if (inhibit_menubar_update)
 13785     return hooks_run;
 13786 
 13787   window = FRAME_SELECTED_WINDOW (f);
 13788   w = XWINDOW (window);
 13789 
 13790   if (FRAME_WINDOW_P (f)
 13791       ?
 13792 #ifdef HAVE_EXT_MENU_BAR
 13793       FRAME_EXTERNAL_MENU_BAR (f)
 13794 #else
 13795       FRAME_MENU_BAR_LINES (f) > 0
 13796 #endif
 13797       : FRAME_MENU_BAR_LINES (f) > 0)
 13798     {
 13799       /* If the user has switched buffers or windows, we need to
 13800          recompute to reflect the new bindings.  But we'll
 13801          recompute when update_mode_lines is set too; that means
 13802          that people can use force-mode-line-update to request
 13803          that the menu bar be recomputed.  The adverse effect on
 13804          the rest of the redisplay algorithm is about the same as
 13805          windows_or_buffers_changed anyway.  */
 13806       if (windows_or_buffers_changed
 13807           /* This used to test w->update_mode_line, but we believe
 13808              there is no need to recompute the menu in that case.  */
 13809           || update_mode_lines
 13810           || window_buffer_changed (w))
 13811         {
 13812           struct buffer *prev = current_buffer;
 13813           specpdl_ref count = SPECPDL_INDEX ();
 13814 
 13815           specbind (Qinhibit_menubar_update, Qt);
 13816 
 13817           set_buffer_internal_1 (XBUFFER (w->contents));
 13818           if (save_match_data)
 13819             record_unwind_save_match_data ();
 13820           if (NILP (Voverriding_local_map_menu_flag))
 13821             {
 13822               specbind (Qoverriding_terminal_local_map, Qnil);
 13823               specbind (Qoverriding_local_map, Qnil);
 13824             }
 13825 
 13826           if (!hooks_run)
 13827             {
 13828               /* Run the Lucid hook.  */
 13829               safe_run_hooks (Qactivate_menubar_hook);
 13830 
 13831               /* If it has changed current-menubar from previous value,
 13832                  really recompute the menu-bar from the value.  */
 13833               safe_run_hooks (Qmenu_bar_update_hook);
 13834 
 13835               hooks_run = true;
 13836             }
 13837 
 13838           XSETFRAME (Vmenu_updating_frame, f);
 13839           fset_menu_bar_items (f, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));
 13840 
 13841           /* Redisplay the menu bar in case we changed it.  */
 13842 #ifdef HAVE_EXT_MENU_BAR
 13843           if (FRAME_WINDOW_P (f))
 13844             {
 13845 #if defined (HAVE_NS)
 13846               /* All frames on Mac OS share the same menubar.  So only
 13847                  the selected frame should be allowed to set it.  */
 13848               if (f == SELECTED_FRAME ())
 13849 #endif
 13850                 set_frame_menubar (f, false);
 13851             }
 13852           else
 13853             /* On a terminal screen, the menu bar is an ordinary screen
 13854                line, and this makes it get updated.  */
 13855             w->update_mode_line = true;
 13856 #else /* ! (HAVE_EXT_MENU_BAR) */
 13857           /* In the non-toolkit version, the menu bar is an ordinary screen
 13858              line, and this makes it get updated.  */
 13859           w->update_mode_line = true;
 13860 #endif /* HAVE_EXT_MENU_BAR */
 13861 
 13862           unbind_to (count, Qnil);
 13863           set_buffer_internal_1 (prev);
 13864         }
 13865     }
 13866 
 13867   return hooks_run;
 13868 }
 13869 
 13870 
 13871 
 13872 /***********************************************************************
 13873                                Tab-bars
 13874  ***********************************************************************/
 13875 
 13876 /* Restore WINDOW as the selected window and its frame as the selected
 13877    frame.  If WINDOW is dead but the selected frame is live, make the
 13878    latter's selected window the selected window.  If both, WINDOW and
 13879    the selected frame, are dead, assign selected frame and window from
 13880    some arbitrary live frame.  Abort if no such frame can be found.  */
 13881 static void
 13882 restore_selected_window (Lisp_Object window)
 13883 {
 13884   if (WINDOW_LIVE_P (window))
 13885     /* If WINDOW is live, make it the selected window and its frame's
 13886        selected window and set the selected frame to its frame.  */
 13887     {
 13888       selected_window = window;
 13889       selected_frame = XWINDOW (window)->frame;
 13890       FRAME_SELECTED_WINDOW (XFRAME (selected_frame)) = window;
 13891     }
 13892   else if (FRAMEP (selected_frame) && FRAME_LIVE_P (XFRAME (selected_frame)))
 13893     /* If WINDOW is dead but the selected frame is still live, make the
 13894        latter's selected window the selected one.  */
 13895     selected_window = FRAME_SELECTED_WINDOW (XFRAME (selected_frame));
 13896   else
 13897     /* If WINDOW and the selected frame are dead, choose some live,
 13898        non-child and non-tooltip frame as the new selected frame and
 13899        make its selected window the selected window.  */
 13900     {
 13901       Lisp_Object tail;
 13902       Lisp_Object frame UNINIT;
 13903 
 13904       FOR_EACH_FRAME (tail, frame)
 13905         {
 13906           struct frame *f = XFRAME (frame);
 13907 
 13908           if (!FRAME_PARENT_FRAME (f) && !FRAME_TOOLTIP_P (f))
 13909             {
 13910               selected_frame = frame;
 13911               selected_window = FRAME_SELECTED_WINDOW (f);
 13912 
 13913               return;
 13914             }
 13915         }
 13916 
 13917       /* Abort if we cannot find a live frame.  */
 13918       emacs_abort ();
 13919     }
 13920 }
 13921 
 13922 /* Restore WINDOW, if live, as its frame's selected window.  */
 13923 static void
 13924 restore_frame_selected_window (Lisp_Object window)
 13925 {
 13926   if (WINDOW_LIVE_P (window))
 13927     /* If WINDOW is live, make it its frame's selected window.  If that
 13928        frame is the selected frame, make WINDOW the selected window as
 13929        well.  */
 13930     {
 13931       Lisp_Object frame = XWINDOW (window)->frame;
 13932 
 13933       FRAME_SELECTED_WINDOW (XFRAME (frame)) = window;
 13934       if (EQ (frame, selected_frame))
 13935         selected_window = window;
 13936     }
 13937 }
 13938 
 13939 /* Update the tab-bar item list for frame F.  This has to be done
 13940    before we start to fill in any display lines.  Called from
 13941    prepare_menu_bars.  If SAVE_MATCH_DATA, we must save
 13942    and restore it here.  */
 13943 
 13944 static void
 13945 update_tab_bar (struct frame *f, bool save_match_data)
 13946 {
 13947   bool do_update = false;
 13948 
 13949 #ifdef HAVE_WINDOW_SYSTEM
 13950   if (FRAME_WINDOW_P (f) && WINDOWP (f->tab_bar_window)) {
 13951     if (WINDOW_TOTAL_LINES (XWINDOW (f->tab_bar_window)) > 0)
 13952       do_update = true;
 13953   }
 13954   else
 13955 #endif
 13956   if (FRAME_TAB_BAR_LINES (f) > 0)
 13957     do_update = true;
 13958 
 13959   if (do_update)
 13960     {
 13961       Lisp_Object window;
 13962       struct window *w;
 13963 
 13964       window = FRAME_SELECTED_WINDOW (f);
 13965       w = XWINDOW (window);
 13966 
 13967       /* If the user has switched buffers or windows, we need to
 13968          recompute to reflect the new bindings.  But we'll
 13969          recompute when update_mode_lines is set too; that means
 13970          that people can use force-mode-line-update to request
 13971          that the menu bar be recomputed.  The adverse effect on
 13972          the rest of the redisplay algorithm is about the same as
 13973          windows_or_buffers_changed anyway.  */
 13974       if (windows_or_buffers_changed
 13975           || w->update_mode_line
 13976           || update_mode_lines
 13977           || window_buffer_changed (w))
 13978         {
 13979           struct buffer *prev = current_buffer;
 13980           specpdl_ref count = SPECPDL_INDEX ();
 13981           Lisp_Object new_tab_bar;
 13982           int new_n_tab_bar;
 13983 
 13984           /* Set current_buffer to the buffer of the selected
 13985              window of the frame, so that we get the right local
 13986              keymaps.  */
 13987           set_buffer_internal_1 (XBUFFER (w->contents));
 13988 
 13989           /* Save match data, if we must.  */
 13990           if (save_match_data)
 13991             record_unwind_save_match_data ();
 13992 
 13993           /* Make sure that we don't accidentally use bogus keymaps.  */
 13994           if (NILP (Voverriding_local_map_menu_flag))
 13995             {
 13996               specbind (Qoverriding_terminal_local_map, Qnil);
 13997               specbind (Qoverriding_local_map, Qnil);
 13998             }
 13999 
 14000           /* We must temporarily set the selected frame to this frame
 14001              before calling tab_bar_items, because the calculation of
 14002              the tab-bar keymap uses the selected frame (see
 14003              `tab-bar-make-keymap' in tab-bar.el).  */
 14004           eassert (EQ (selected_window,
 14005                        /* Since we only explicitly preserve selected_frame,
 14006                           check that selected_window would be redundant.  */
 14007                        XFRAME (selected_frame)->selected_window));
 14008 #ifdef HAVE_WINDOW_SYSTEM
 14009           Lisp_Object frame;
 14010           record_unwind_protect (restore_selected_window, selected_window);
 14011           XSETFRAME (frame, f);
 14012           selected_frame = frame;
 14013           selected_window = FRAME_SELECTED_WINDOW (f);
 14014 #endif
 14015 
 14016           /* Build desired tab-bar items from keymaps.  */
 14017           new_tab_bar
 14018             = tab_bar_items (Fcopy_sequence (f->tab_bar_items),
 14019                               &new_n_tab_bar);
 14020 
 14021           /* Redisplay the tab-bar if we changed it.  */
 14022           if (new_n_tab_bar != f->n_tab_bar_items
 14023               || NILP (Fequal (new_tab_bar, f->tab_bar_items)))
 14024             {
 14025               /* Redisplay that happens asynchronously due to an expose event
 14026                  may access f->tab_bar_items.  Make sure we update both
 14027                  variables within BLOCK_INPUT so no such event interrupts.  */
 14028               block_input ();
 14029               fset_tab_bar_items (f, new_tab_bar);
 14030               f->n_tab_bar_items = new_n_tab_bar;
 14031               w->update_mode_line = true;
 14032               unblock_input ();
 14033             }
 14034 
 14035           unbind_to (count, Qnil);
 14036           set_buffer_internal_1 (prev);
 14037         }
 14038     }
 14039 }
 14040 
 14041 /* Redisplay the tab bar in the frame for window W.
 14042 
 14043    The tab bar of X frames that don't have X toolkit support is
 14044    displayed in a special window W->frame->tab_bar_window.
 14045 
 14046    The tab bar of terminal frames is treated specially as far as
 14047    glyph matrices are concerned.  Tab bar lines are not part of
 14048    windows, so the update is done directly on the frame matrix rows
 14049    for the tab bar.  */
 14050 
 14051 static void
 14052 display_tab_bar (struct window *w)
 14053 {
 14054   struct frame *f = XFRAME (WINDOW_FRAME (w));
 14055   struct it it;
 14056   Lisp_Object items;
 14057   int i;
 14058 
 14059   /* Don't do all this for graphical frames.  */
 14060 #ifdef HAVE_NTGUI
 14061   if (FRAME_W32_P (f))
 14062     return;
 14063 #endif
 14064 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
 14065   if (FRAME_X_P (f))
 14066     return;
 14067 #endif
 14068 
 14069 #ifdef HAVE_NS
 14070   if (FRAME_NS_P (f))
 14071     return;
 14072 #endif /* HAVE_NS */
 14073 
 14074 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
 14075   eassert (!FRAME_WINDOW_P (f));
 14076   init_iterator (&it, w, -1, -1, f->desired_matrix->rows
 14077                  + (FRAME_MENU_BAR_LINES (f) > 0 ? 1 : 0),
 14078                  TAB_BAR_FACE_ID);
 14079   it.first_visible_x = 0;
 14080   it.last_visible_x = FRAME_PIXEL_WIDTH (f);
 14081 #elif defined (HAVE_X_WINDOWS) /* X without toolkit.  */
 14082   if (FRAME_WINDOW_P (f))
 14083     {
 14084       /* Tab bar lines are displayed in the desired matrix of the
 14085          dummy window tab_bar_window.  */
 14086       struct window *tab_w;
 14087       tab_w = XWINDOW (f->tab_bar_window);
 14088       init_iterator (&it, tab_w, -1, -1, tab_w->desired_matrix->rows,
 14089                      TAB_BAR_FACE_ID);
 14090       it.first_visible_x = 0;
 14091       it.last_visible_x = FRAME_PIXEL_WIDTH (f);
 14092     }
 14093   else
 14094 #endif /* not USE_X_TOOLKIT and not USE_GTK */
 14095     {
 14096       /* This is a TTY frame, i.e. character hpos/vpos are used as
 14097          pixel x/y.  */
 14098       init_iterator (&it, w, -1, -1, f->desired_matrix->rows
 14099                      + (FRAME_MENU_BAR_LINES (f) > 0 ? 1 : 0),
 14100                      TAB_BAR_FACE_ID);
 14101       it.first_visible_x = 0;
 14102       it.last_visible_x = FRAME_COLS (f);
 14103     }
 14104 
 14105   /* FIXME: This should be controlled by a user option.  See the
 14106      comments in redisplay_tool_bar and display_mode_line about
 14107      this.  */
 14108   it.paragraph_embedding = L2R;
 14109 
 14110   /* Clear all rows of the tab bar.  */
 14111   for (i = 0; i < FRAME_TAB_BAR_LINES (f); ++i)
 14112     {
 14113       struct glyph_row *row = it.glyph_row + i;
 14114       clear_glyph_row (row);
 14115       row->enabled_p = true;
 14116       row->full_width_p = true;
 14117       row->reversed_p = false;
 14118     }
 14119 
 14120   /* Display all items of the tab bar.  */
 14121   items = it.f->tab_bar_items;
 14122   int j;
 14123   for (i = 0, j = 0; i < it.f->n_tab_bar_items; ++i, j += TAB_BAR_ITEM_NSLOTS)
 14124     {
 14125       Lisp_Object string = AREF (items, j + TAB_BAR_ITEM_CAPTION);
 14126 
 14127       /* Stop at nil string.  */
 14128       if (NILP (string))
 14129         break;
 14130 
 14131       if (it.current_x < it.last_visible_x)
 14132         display_string (NULL, string, Qnil, 0, 0, &it,
 14133                         SCHARS (string), 0, 0, STRING_MULTIBYTE (string));
 14134     }
 14135 
 14136   /* Fill out the line with spaces.  */
 14137   if (it.current_x < it.last_visible_x)
 14138     display_string ("", Qnil, Qnil, 0, 0, &it, -1, 0, 0, -1);
 14139 
 14140   /* Compute the total height of the lines.  */
 14141   compute_line_metrics (&it);
 14142 }
 14143 
 14144 #ifdef HAVE_WINDOW_SYSTEM
 14145 
 14146 /* Set F->desired_tab_bar_string to a Lisp string representing frame
 14147    F's desired tab-bar contents.  F->tab_bar_items must have
 14148    been set up previously by calling prepare_menu_bars.  */
 14149 
 14150 static void
 14151 build_desired_tab_bar_string (struct frame *f)
 14152 {
 14153   int i;
 14154   Lisp_Object caption;
 14155 
 14156   caption = Qnil;
 14157 
 14158   /* Prepare F->desired_tab_bar_string.  Make a new string.  */
 14159   fset_desired_tab_bar_string (f, build_string (""));
 14160 
 14161   /* Put a `display' property on the string for the captions to display,
 14162      put a `menu_item' property on tab-bar items with a value that
 14163      is the index of the item in F's tab-bar item vector.  */
 14164   for (i = 0; i < f->n_tab_bar_items; ++i)
 14165     {
 14166 #define PROP(IDX) \
 14167   AREF (f->tab_bar_items, i * TAB_BAR_ITEM_NSLOTS + (IDX))
 14168 
 14169       caption = Fcopy_sequence (PROP (TAB_BAR_ITEM_CAPTION));
 14170 
 14171       /* Put a `display' text property on the string for the caption to
 14172          display.  Put a `menu-item' property on the string that gives
 14173          the start of this item's properties in the tab-bar items
 14174          vector.  */
 14175       AUTO_LIST2 (props, Qmenu_item, make_fixnum (i * TAB_BAR_ITEM_NSLOTS));
 14176 
 14177       Fadd_text_properties (make_fixnum (0), make_fixnum (SCHARS (caption)),
 14178                             props, caption);
 14179 
 14180       f->desired_tab_bar_string =
 14181         concat2 (f->desired_tab_bar_string, caption);
 14182 
 14183 #undef PROP
 14184     }
 14185 }
 14186 
 14187 
 14188 /* Display one line of the tab-bar of frame IT->f.
 14189 
 14190    HEIGHT specifies the desired height of the tab-bar line.
 14191    If the actual height of the glyph row is less than HEIGHT, the
 14192    row's height is increased to HEIGHT, and the icons are centered
 14193    vertically in the new height.
 14194 
 14195    If HEIGHT is -1, we are counting needed tab-bar lines, so don't
 14196    count a final empty row in case the tab-bar width exactly matches
 14197    the window width.
 14198 */
 14199 
 14200 static void
 14201 display_tab_bar_line (struct it *it, int height)
 14202 {
 14203   struct glyph_row *row = it->glyph_row;
 14204   int max_x = it->last_visible_x;
 14205   struct glyph *last;
 14206 
 14207   /* Don't extend on a previously drawn tab bar items (Bug#16058).  */
 14208   clear_glyph_row (row);
 14209   row->enabled_p = true;
 14210   row->y = it->current_y;
 14211 
 14212   /* Note that this isn't made use of if the face hasn't a box,
 14213      so there's no need to check the face here.  */
 14214   it->start_of_box_run_p = true;
 14215 
 14216   bool enough = false;
 14217   while (it->current_x < max_x)
 14218     {
 14219       int x, n_glyphs_before, i, nglyphs;
 14220       struct it it_before;
 14221 
 14222       /* Get the next display element.  */
 14223       if (!get_next_display_element (it))
 14224         {
 14225           /* Don't count empty row if we are counting needed tab-bar lines.  */
 14226           if (height < 0 && !it->hpos)
 14227             return;
 14228           break;
 14229         }
 14230 
 14231       /* Produce glyphs.  */
 14232       n_glyphs_before = row->used[TEXT_AREA];
 14233       it_before = *it;
 14234 
 14235       PRODUCE_GLYPHS (it);
 14236 
 14237       nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
 14238       i = 0;
 14239       x = it_before.current_x;
 14240       while (i < nglyphs)
 14241         {
 14242           struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
 14243 
 14244           if (x + glyph->pixel_width > max_x)
 14245             {
 14246               /* Glyph doesn't fit on line.  Backtrack.  */
 14247               row->used[TEXT_AREA] = n_glyphs_before;
 14248               *it = it_before;
 14249               /* If this is the only glyph on this line, it will never fit on the
 14250                  tab-bar, so skip it.  But ensure there is at least one glyph,
 14251                  so we don't accidentally disable the tab-bar.  */
 14252               if (n_glyphs_before == 0
 14253                   && (it->vpos > 0 || IT_STRING_CHARPOS (*it) < it->end_charpos-1))
 14254                 break;
 14255               goto out;
 14256             }
 14257 
 14258           ++it->hpos;
 14259           x += glyph->pixel_width;
 14260           ++i;
 14261         }
 14262 
 14263       enough = ITERATOR_AT_END_OF_LINE_P (it);
 14264       set_iterator_to_next (it, true);
 14265 
 14266       /* Stop at line end.  */
 14267       if (enough)
 14268         break;
 14269     }
 14270 
 14271  out:;
 14272 
 14273   row->displays_text_p = row->used[TEXT_AREA] != 0;
 14274 
 14275   /* Use default face for the border below the tab bar.
 14276 
 14277      FIXME: When auto-resize-tab-bars is grow-only, there is
 14278      no additional border below the possibly empty tab-bar lines.
 14279      So to make the extra empty lines look "normal", we have to
 14280      use the tab-bar face for the border too.  */
 14281   if (!MATRIX_ROW_DISPLAYS_TEXT_P (row)
 14282       && !EQ (Vauto_resize_tab_bars, Qgrow_only))
 14283     it->face_id = DEFAULT_FACE_ID;
 14284 
 14285   extend_face_to_end_of_line (it);
 14286   last = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
 14287   last->right_box_line_p = true;
 14288   if (last == row->glyphs[TEXT_AREA])
 14289     last->left_box_line_p = true;
 14290 
 14291   /* Make line the desired height and center it vertically.  */
 14292   if ((height -= it->max_ascent + it->max_descent) > 0)
 14293     {
 14294       /* Don't add more than one line height.  */
 14295       height %= FRAME_LINE_HEIGHT (it->f);
 14296       it->max_ascent += height / 2;
 14297       it->max_descent += (height + 1) / 2;
 14298     }
 14299 
 14300   compute_line_metrics (it);
 14301 
 14302   /* If line is empty, make it occupy the rest of the tab-bar.  */
 14303   if (!MATRIX_ROW_DISPLAYS_TEXT_P (row))
 14304     {
 14305       row->height = row->phys_height = it->last_visible_y - row->y;
 14306       row->visible_height = row->height;
 14307       row->ascent = row->phys_ascent = 0;
 14308       row->extra_line_spacing = 0;
 14309     }
 14310 
 14311   row->full_width_p = true;
 14312   row->continued_p = false;
 14313   row->truncated_on_left_p = false;
 14314   row->truncated_on_right_p = false;
 14315 
 14316   it->current_x = it->hpos = 0;
 14317   it->current_y += row->height;
 14318   ++it->vpos;
 14319   ++it->glyph_row;
 14320 }
 14321 
 14322 
 14323 /* Value is the number of pixels needed to make all tab-bar items of
 14324    frame F visible.  The actual number of glyph rows needed is
 14325    returned in *N_ROWS if non-NULL.  */
 14326 static int
 14327 tab_bar_height (struct frame *f, int *n_rows, bool pixelwise)
 14328 {
 14329   struct window *w = XWINDOW (f->tab_bar_window);
 14330   struct it it;
 14331   /* tab_bar_height is called from redisplay_tab_bar after building
 14332      the desired matrix, so use (unused) mode-line row as temporary row to
 14333      avoid destroying the first tab-bar row.  */
 14334   struct glyph_row *temp_row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
 14335 
 14336   /* Initialize an iterator for iteration over
 14337      F->desired_tab_bar_string in the tab-bar window of frame F.  */
 14338   init_iterator (&it, w, -1, -1, temp_row, TAB_BAR_FACE_ID);
 14339   temp_row->reversed_p = false;
 14340   it.first_visible_x = 0;
 14341   it.last_visible_x = WINDOW_PIXEL_WIDTH (w);
 14342   reseat_to_string (&it, NULL, f->desired_tab_bar_string,
 14343                     0, 0, 0, STRING_MULTIBYTE (f->desired_tab_bar_string));
 14344   it.paragraph_embedding = L2R;
 14345 
 14346   clear_glyph_row (temp_row);
 14347   while (!ITERATOR_AT_END_P (&it))
 14348     {
 14349       it.glyph_row = temp_row;
 14350       display_tab_bar_line (&it, -1);
 14351     }
 14352   clear_glyph_row (temp_row);
 14353 
 14354   /* f->n_tab_bar_rows == 0 means "unknown"; -1 means no tab-bar.  */
 14355   if (n_rows)
 14356     *n_rows = it.vpos > 0 ? it.vpos : -1;
 14357 
 14358   if (pixelwise)
 14359     return it.current_y;
 14360   else
 14361     return (it.current_y + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
 14362 }
 14363 
 14364 DEFUN ("tab-bar-height", Ftab_bar_height, Stab_bar_height,
 14365        0, 2, 0,
 14366        doc: /* Return the number of lines occupied by the tab bar of FRAME.
 14367 If FRAME is nil or omitted, use the selected frame.  Optional argument
 14368 PIXELWISE non-nil means return the height of the tab bar in pixels.  */)
 14369   (Lisp_Object frame, Lisp_Object pixelwise)
 14370 {
 14371   int height = 0;
 14372 
 14373   struct frame *f = decode_any_frame (frame);
 14374 
 14375   if (WINDOWP (f->tab_bar_window)
 14376       && WINDOW_PIXEL_HEIGHT (XWINDOW (f->tab_bar_window)) > 0)
 14377     {
 14378       update_tab_bar (f, true);
 14379       if (f->n_tab_bar_items)
 14380         {
 14381           build_desired_tab_bar_string (f);
 14382           height = tab_bar_height (f, NULL, !NILP (pixelwise));
 14383         }
 14384     }
 14385 
 14386   return make_fixnum (height);
 14387 }
 14388 
 14389 
 14390 /* Display the tab-bar of frame F.  Value is true if tab-bar's
 14391    height should be changed.  */
 14392 static bool
 14393 redisplay_tab_bar (struct frame *f)
 14394 {
 14395   struct window *w;
 14396   struct it it;
 14397   struct glyph_row *row;
 14398 
 14399   f->tab_bar_redisplayed = true;
 14400 
 14401   /* If frame hasn't a tab-bar window or if it is zero-height, don't
 14402      do anything.  This means you must start with tab-bar-lines
 14403      non-zero to get the auto-sizing effect.  Or in other words, you
 14404      can turn off tab-bars by specifying tab-bar-lines zero.  */
 14405   if (!WINDOWP (f->tab_bar_window)
 14406       || (w = XWINDOW (f->tab_bar_window),
 14407           WINDOW_TOTAL_LINES (w) == 0))
 14408     {
 14409       /* Even if we do not display a tab bar initially, still pretend
 14410          that we have resized it.  This avoids that a later activation
 14411          of the tab bar resizes the frame, despite of the fact that the
 14412          setting of 'frame-inhibit-implied-resize' should inhibit it
 14413          (Bug#52986).  */
 14414       f->tab_bar_resized = true;
 14415 
 14416       return false;
 14417     }
 14418 
 14419   /* Build a string that represents the contents of the tab-bar.  */
 14420   build_desired_tab_bar_string (f);
 14421 
 14422   int new_nrows;
 14423   int new_height = tab_bar_height (f, &new_nrows, true);
 14424 
 14425   if (f->n_tab_bar_rows == 0)
 14426     {
 14427       f->n_tab_bar_rows = new_nrows;
 14428       if (new_height != WINDOW_PIXEL_HEIGHT (w))
 14429         frame_default_tab_bar_height = new_height;
 14430     }
 14431 
 14432   /* If new_height or new_nrows indicate that we need to enlarge or
 14433      shrink the tab-bar window, we can return right away.  */
 14434   if (new_nrows > f->n_tab_bar_rows
 14435       || (EQ (Vauto_resize_tab_bars, Qgrow_only)
 14436           && !f->minimize_tab_bar_window_p
 14437           && new_height > WINDOW_PIXEL_HEIGHT (w))
 14438       || (! EQ (Vauto_resize_tab_bars, Qgrow_only)
 14439           && new_height < WINDOW_PIXEL_HEIGHT (w)))
 14440     {
 14441       if (FRAME_TERMINAL (f)->change_tab_bar_height_hook)
 14442         FRAME_TERMINAL (f)->change_tab_bar_height_hook (f, new_height);
 14443       if (new_nrows != f->n_tab_bar_rows)
 14444         f->n_tab_bar_rows = new_nrows;
 14445       clear_glyph_matrix (w->desired_matrix);
 14446       f->fonts_changed = true;
 14447       return true;
 14448     }
 14449 
 14450   /* Set up an iterator for the tab-bar window.  */
 14451   init_iterator (&it, w, -1, -1, w->desired_matrix->rows, TAB_BAR_FACE_ID);
 14452   it.first_visible_x = 0;
 14453   it.last_visible_x = WINDOW_PIXEL_WIDTH (w);
 14454   row = it.glyph_row;
 14455   row->reversed_p = false;
 14456   reseat_to_string (&it, NULL, f->desired_tab_bar_string, 0, 0, 0,
 14457                     STRING_MULTIBYTE (f->desired_tab_bar_string));
 14458   /* FIXME: This should be controlled by a user option.  But it
 14459      doesn't make sense to have an R2L tab bar if the menu bar cannot
 14460      be drawn also R2L, and making the menu bar R2L is tricky due
 14461      tabkit-specific code that implements it.  If an R2L tab bar is
 14462      ever supported, display_tab_bar_line should also be augmented to
 14463      call unproduce_glyphs like display_line and display_string
 14464      do.  */
 14465   it.paragraph_embedding = L2R;
 14466 
 14467   /* Display as many lines as needed to display all tab-bar items.  */
 14468 
 14469   if (f->n_tab_bar_rows > 0)
 14470     {
 14471       int border, rows, height, extra;
 14472 
 14473       if (TYPE_RANGED_FIXNUMP (int, Vtab_bar_border))
 14474         border = XFIXNUM (Vtab_bar_border);
 14475       else if (EQ (Vtab_bar_border, Qinternal_border_width))
 14476         border = FRAME_INTERNAL_BORDER_WIDTH (f);
 14477       else if (EQ (Vtab_bar_border, Qborder_width))
 14478         border = f->border_width;
 14479       else
 14480         border = 0;
 14481       if (border < 0)
 14482         border = 0;
 14483 
 14484       rows = f->n_tab_bar_rows;
 14485       height = max (1, (it.last_visible_y - border) / rows);
 14486       extra = it.last_visible_y - border - height * rows;
 14487 
 14488       while (it.current_y < it.last_visible_y)
 14489         {
 14490           int h = 0;
 14491           if (extra > 0 && rows-- > 0)
 14492             {
 14493               h = (extra + rows - 1) / rows;
 14494               extra -= h;
 14495             }
 14496           display_tab_bar_line (&it, height + h);
 14497         }
 14498     }
 14499   else
 14500     {
 14501       while (it.current_y < it.last_visible_y)
 14502         display_tab_bar_line (&it, 0);
 14503     }
 14504 
 14505   /* It doesn't make much sense to try scrolling in the tab-bar
 14506      window, so don't do it.  */
 14507   w->desired_matrix->no_scrolling_p = true;
 14508   w->must_be_updated_p = true;
 14509 
 14510   if (!NILP (Vauto_resize_tab_bars))
 14511     {
 14512       bool change_height_p = false;
 14513 
 14514       /* If we couldn't display everything, change the tab-bar's
 14515          height if there is room for more.  */
 14516       if (IT_STRING_CHARPOS (it) < it.end_charpos)
 14517         change_height_p = true;
 14518 
 14519       /* We subtract 1 because display_tab_bar_line advances the
 14520          glyph_row pointer before returning to its caller.  We want to
 14521          examine the last glyph row produced by
 14522          display_tab_bar_line.  */
 14523       row = it.glyph_row - 1;
 14524 
 14525       /* If there are blank lines at the end, except for a partially
 14526          visible blank line at the end that is smaller than
 14527          FRAME_LINE_HEIGHT, change the tab-bar's height.  */
 14528       if (!MATRIX_ROW_DISPLAYS_TEXT_P (row)
 14529           && row->height >= FRAME_LINE_HEIGHT (f))
 14530         change_height_p = true;
 14531 
 14532       /* If row displays tab-bar items, but is partially visible,
 14533          change the tab-bar's height.  */
 14534       if (MATRIX_ROW_DISPLAYS_TEXT_P (row)
 14535           && MATRIX_ROW_BOTTOM_Y (row) > it.last_visible_y)
 14536         change_height_p = true;
 14537 
 14538       /* Resize windows as needed by changing the `tab-bar-lines'
 14539          frame parameter.  */
 14540       if (change_height_p)
 14541         {
 14542           int nrows;
 14543           int new_height = tab_bar_height (f, &nrows, true);
 14544 
 14545           change_height_p = ((EQ (Vauto_resize_tab_bars, Qgrow_only)
 14546                               && !f->minimize_tab_bar_window_p)
 14547                              ? (new_height > WINDOW_PIXEL_HEIGHT (w))
 14548                              : (new_height != WINDOW_PIXEL_HEIGHT (w)));
 14549           f->minimize_tab_bar_window_p = false;
 14550 
 14551           if (change_height_p)
 14552             {
 14553               if (FRAME_TERMINAL (f)->change_tab_bar_height_hook)
 14554                 FRAME_TERMINAL (f)->change_tab_bar_height_hook (f, new_height);
 14555               frame_default_tab_bar_height = new_height;
 14556               clear_glyph_matrix (w->desired_matrix);
 14557               f->n_tab_bar_rows = nrows;
 14558               f->fonts_changed = true;
 14559 
 14560               return true;
 14561             }
 14562         }
 14563     }
 14564 
 14565   f->minimize_tab_bar_window_p = false;
 14566   return false;
 14567 }
 14568 
 14569 /* Get information about the tab-bar item which is displayed in GLYPH
 14570    on frame F.  Return in *PROP_IDX the index where tab-bar item
 14571    properties start in F->tab_bar_items.  Return in CLOSE_P an
 14572    indication whether the click was on the close-tab icon of the tab.
 14573    Value is false if GLYPH doesn't display a tab-bar item.  */
 14574 
 14575 static bool
 14576 tab_bar_item_info (struct frame *f, struct glyph *glyph,
 14577                    int *prop_idx, bool *close_p)
 14578 {
 14579   Lisp_Object prop;
 14580   ptrdiff_t charpos;
 14581 
 14582   /* This function can be called asynchronously, which means we must
 14583      exclude any possibility that Fget_text_property signals an
 14584      error.  */
 14585   charpos = min (SCHARS (f->current_tab_bar_string), glyph->charpos);
 14586   charpos = max (0, charpos);
 14587 
 14588   /* Get the text property `menu-item' at pos. The value of that
 14589      property is the start index of this item's properties in
 14590      F->tab_bar_items.  */
 14591   prop = Fget_text_property (make_fixnum (charpos),
 14592                              Qmenu_item, f->current_tab_bar_string);
 14593   if (! FIXNUMP (prop))
 14594     return false;
 14595 
 14596   *prop_idx = XFIXNUM (prop);
 14597 
 14598   if (close_p)
 14599     *close_p = !NILP (Fget_text_property (make_fixnum (charpos),
 14600                                           Qclose_tab,
 14601                                           f->current_tab_bar_string));
 14602 
 14603   return true;
 14604 }
 14605 
 14606 
 14607 /* Get information about the tab-bar item at position X/Y on frame F's
 14608    tab bar window.
 14609 
 14610    Set *GLYPH to a pointer to the glyph of the tab-bar item in the
 14611    current matrix of the tab-bar window of F, or NULL if not on a
 14612    tab-bar item.  Return in *PROP_IDX the index of the tab-bar item in
 14613    F->tab_bar_items.
 14614 
 14615    Place the window-relative vpos of Y in *VPOS, and the
 14616    window-relative hpos of X in *HPOS.  If CLOSE_P, set it to whether
 14617    or not the tab bar item represents a button that should close a
 14618    tab.
 14619 
 14620    Value is
 14621 
 14622    -1   if X/Y is not on a tab-bar item
 14623    0    if X/Y is on the same item that was highlighted before.
 14624    1    otherwise.  */
 14625 
 14626 static int
 14627 get_tab_bar_item (struct frame *f, int x, int y, struct glyph **glyph,
 14628                   int *hpos, int *vpos, int *prop_idx, bool *close_p)
 14629 {
 14630   struct window *w = XWINDOW (f->tab_bar_window);
 14631   int area;
 14632 
 14633   /* Find the glyph under X/Y.  */
 14634   *glyph = x_y_to_hpos_vpos (w, x, y, hpos, vpos, 0, 0, &area);
 14635   if (*glyph == NULL)
 14636     return -1;
 14637 
 14638   /* Get the start of this tab-bar item's properties in
 14639      f->tab_bar_items.  */
 14640   if (!tab_bar_item_info (f, *glyph, prop_idx, close_p))
 14641     return -1;
 14642 
 14643   return *prop_idx == f->last_tab_bar_item ? 0 : 1;
 14644 }
 14645 
 14646 /* EXPORT:
 14647 
 14648    Like `get_tab_bar_item'.  However, don't return anything for GLYPH,
 14649    HPOS, or VPOS, and treat X and Y as relative to F itself, as
 14650    opposed to its tab bar window.  */
 14651 
 14652 int
 14653 get_tab_bar_item_kbd (struct frame *f, int x, int y, int *prop_idx,
 14654                       bool *close_p)
 14655 {
 14656   struct window *w;
 14657   int area, vpos, hpos;
 14658   struct glyph *glyph;
 14659 
 14660   w = XWINDOW (f->tab_bar_window);
 14661 
 14662   /* Convert X and Y to window coordinates.  */
 14663   frame_to_window_pixel_xy (w, &x, &y);
 14664 
 14665   /* Find the glyph under X/Y.  */
 14666   glyph = x_y_to_hpos_vpos (w, x, y, &hpos, &vpos, 0,
 14667                             0, &area);
 14668   if (glyph == NULL)
 14669     return -1;
 14670 
 14671   /* Get the start of this tab-bar item's properties in
 14672      f->tab_bar_items.  */
 14673   if (!tab_bar_item_info (f, glyph, prop_idx, close_p))
 14674     return -1;
 14675 
 14676   return *prop_idx == f->last_tab_bar_item ? 0 : 1;
 14677 }
 14678 
 14679 /* EXPORT:
 14680    Handle mouse button event on the tab-bar of frame F, at
 14681    frame-relative coordinates X/Y.  DOWN_P is true for a button press,
 14682    false for button release.  MODIFIERS is event modifiers for button
 14683    release.  */
 14684 
 14685 Lisp_Object
 14686 handle_tab_bar_click (struct frame *f, int x, int y, bool down_p,
 14687                       int modifiers)
 14688 {
 14689   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 14690   struct window *w = XWINDOW (f->tab_bar_window);
 14691   int hpos, vpos, prop_idx;
 14692   bool close_p;
 14693   struct glyph *glyph;
 14694   Lisp_Object enabled_p;
 14695   int ts;
 14696 
 14697   frame_to_window_pixel_xy (w, &x, &y);
 14698   ts = get_tab_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx, &close_p);
 14699   if (ts == -1)
 14700     return Fcons (Qtab_bar, Qnil);
 14701 
 14702   /* If item is disabled, do nothing.  */
 14703   enabled_p = AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_ENABLED_P);
 14704   if (NILP (enabled_p))
 14705     return Qnil;
 14706 
 14707   if (down_p)
 14708     {
 14709       /* Show the clicked button in pressed state.  */
 14710       if (!NILP (Vmouse_highlight))
 14711         show_mouse_face (hlinfo, DRAW_IMAGE_SUNKEN);
 14712       f->last_tab_bar_item = prop_idx; /* record the pressed tab */
 14713     }
 14714   else
 14715     {
 14716       /* Show item in released state.  */
 14717       if (!NILP (Vmouse_highlight))
 14718         show_mouse_face (hlinfo, DRAW_IMAGE_RAISED);
 14719       f->last_tab_bar_item = -1;
 14720     }
 14721 
 14722   Lisp_Object caption =
 14723     Fcopy_sequence (AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_CAPTION));
 14724 
 14725   AUTO_LIST2 (props, Qmenu_item,
 14726               list3 (AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_KEY),
 14727                      AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_BINDING),
 14728                      close_p ? Qt : Qnil));
 14729 
 14730   Fadd_text_properties (make_fixnum (0), make_fixnum (SCHARS (caption)),
 14731                         props, caption);
 14732 
 14733   return Fcons (Qtab_bar, Fcons (caption, make_fixnum (0)));
 14734 }
 14735 
 14736 
 14737 /* Possibly highlight a tab-bar item on frame F when mouse moves to
 14738    tab-bar window-relative coordinates X/Y.  Called from
 14739    note_mouse_highlight.  */
 14740 
 14741 static void
 14742 note_tab_bar_highlight (struct frame *f, int x, int y)
 14743 {
 14744   Lisp_Object window = f->tab_bar_window;
 14745   struct window *w = XWINDOW (window);
 14746   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 14747   int hpos, vpos;
 14748   struct glyph *glyph;
 14749   struct glyph_row *row;
 14750   int i;
 14751   Lisp_Object enabled_p;
 14752   int prop_idx;
 14753   bool close_p;
 14754   enum draw_glyphs_face draw = DRAW_IMAGE_RAISED;
 14755   int rc;
 14756 
 14757   /* Function note_mouse_highlight is called with negative X/Y
 14758      values when mouse moves outside of the frame.  */
 14759   if (x <= 0 || y <= 0)
 14760     {
 14761       clear_mouse_face (hlinfo);
 14762       return;
 14763     }
 14764 
 14765   rc = get_tab_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx, &close_p);
 14766   if (rc < 0)
 14767     {
 14768       /* Not on tab-bar item.  */
 14769       clear_mouse_face (hlinfo);
 14770       return;
 14771     }
 14772   else if (rc == 0)
 14773     /* On same tab-bar item as before.  */
 14774     goto set_help_echo;
 14775 
 14776   clear_mouse_face (hlinfo);
 14777 
 14778   bool mouse_down_p = false;
 14779   /* Mouse is down, but on different tab-bar item?  Or alternatively,
 14780      the mouse might've been pressed somewhere we don't know about,
 14781      and then have moved onto the tab bar.  In this case,
 14782      last_tab_bar_item is -1, so we DTRT and behave like other
 14783      programs by displaying the item as sunken. */
 14784   Display_Info *dpyinfo = FRAME_DISPLAY_INFO (f);
 14785   mouse_down_p = (gui_mouse_grabbed (dpyinfo)
 14786                   && f == dpyinfo->last_mouse_frame);
 14787 
 14788   if (mouse_down_p && f->last_tab_bar_item != prop_idx
 14789       && f->last_tab_bar_item != -1)
 14790     return;
 14791   draw = mouse_down_p ? DRAW_IMAGE_SUNKEN : DRAW_IMAGE_RAISED;
 14792 
 14793   /* If tab-bar item is not enabled, don't highlight it.  */
 14794   enabled_p = AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_ENABLED_P);
 14795   if (!NILP (enabled_p) && !NILP (Vmouse_highlight))
 14796     {
 14797       /* Compute the x-position of the glyph.  In front and past the
 14798          image is a space.  We include this in the highlighted area.  */
 14799       row = MATRIX_ROW (w->current_matrix, vpos);
 14800       for (i = x = 0; i < hpos; ++i)
 14801         x += row->glyphs[TEXT_AREA][i].pixel_width;
 14802 
 14803       /* Record this as the current active region.  */
 14804       hlinfo->mouse_face_beg_col = hpos;
 14805       hlinfo->mouse_face_beg_row = vpos;
 14806       hlinfo->mouse_face_beg_x = x;
 14807       hlinfo->mouse_face_past_end = false;
 14808 
 14809       hlinfo->mouse_face_end_col = hpos + 1;
 14810       hlinfo->mouse_face_end_row = vpos;
 14811       hlinfo->mouse_face_end_x = x + glyph->pixel_width;
 14812       hlinfo->mouse_face_window = window;
 14813       hlinfo->mouse_face_face_id = TAB_BAR_FACE_ID;
 14814 
 14815       /* Display it as active.  */
 14816       show_mouse_face (hlinfo, draw);
 14817     }
 14818 
 14819  set_help_echo:
 14820 
 14821   /* Set help_echo_string to a help string to display for this tab-bar item.
 14822      XTread_socket does the rest.  */
 14823   help_echo_object = help_echo_window = Qnil;
 14824   help_echo_pos = -1;
 14825   help_echo_string = AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_HELP);
 14826   if (NILP (help_echo_string))
 14827     help_echo_string = AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_CAPTION);
 14828 }
 14829 
 14830 #endif /* HAVE_WINDOW_SYSTEM */
 14831 
 14832 /* Find the tab-bar item at X coordinate and return its information.  */
 14833 static Lisp_Object
 14834 tty_get_tab_bar_item (struct frame *f, int x, int *prop_idx, bool *close_p)
 14835 {
 14836   ptrdiff_t clen = 0;
 14837 
 14838   for (int i = 0; i < f->n_tab_bar_items; i++)
 14839     {
 14840       Lisp_Object caption = AREF (f->tab_bar_items, (i * TAB_BAR_ITEM_NSLOTS
 14841                                                      + TAB_BAR_ITEM_CAPTION));
 14842       if (NILP (caption))
 14843         return Qnil;
 14844       clen += SCHARS (caption);
 14845       if (x < clen)
 14846         {
 14847           *prop_idx = i;
 14848           *close_p = !NILP (Fget_text_property (make_fixnum (SCHARS (caption)
 14849                                                              - (clen - x)),
 14850                                                 Qclose_tab,
 14851                                                 caption));
 14852           return caption;
 14853         }
 14854     }
 14855   return Qnil;
 14856 }
 14857 
 14858 /* Handle a mouse click at X/Y on the tab bar of TTY frame F.  If the
 14859    click was on the tab bar and was handled, populate the EVENT
 14860    structure, store it in keyboard queue, and return true; otherwise
 14861    return false.  MODIFIERS are event modifiers for generating the tab
 14862    release event.  */
 14863 Lisp_Object
 14864 tty_handle_tab_bar_click (struct frame *f, int x, int y, bool down_p,
 14865                           struct input_event *event)
 14866 {
 14867   /* Did they click on the tab bar?  */
 14868   if (y < FRAME_MENU_BAR_LINES (f)
 14869       || y >= FRAME_MENU_BAR_LINES (f) + FRAME_TAB_BAR_LINES (f))
 14870     return Qnil;
 14871 
 14872   /* Find the tab-bar item where the X,Y coordinates belong.  */
 14873   int prop_idx;
 14874   bool close_p;
 14875   Lisp_Object caption = tty_get_tab_bar_item (f, x, &prop_idx, &close_p);
 14876 
 14877   if (NILP (caption))
 14878     return Qnil;
 14879 
 14880   if (NILP (AREF (f->tab_bar_items,
 14881                   prop_idx * TAB_BAR_ITEM_NSLOTS + TAB_BAR_ITEM_ENABLED_P)))
 14882     return Qnil;
 14883 
 14884   if (down_p)
 14885     f->last_tab_bar_item = prop_idx;
 14886   else
 14887     f->last_tab_bar_item = -1;
 14888 
 14889   caption = Fcopy_sequence (caption);
 14890 
 14891   AUTO_LIST2 (props, Qmenu_item,
 14892               list3 (AREF (f->tab_bar_items, prop_idx * TAB_BAR_ITEM_NSLOTS
 14893                            + TAB_BAR_ITEM_KEY),
 14894                      AREF (f->tab_bar_items, prop_idx * TAB_BAR_ITEM_NSLOTS
 14895                            + TAB_BAR_ITEM_BINDING),
 14896                      close_p ? Qt : Qnil));
 14897 
 14898   Fadd_text_properties (make_fixnum (0), make_fixnum (SCHARS (caption)),
 14899                         props, caption);
 14900 
 14901   return Fcons (Qtab_bar, Fcons (caption, make_fixnum (0)));
 14902 }
 14903 
 14904 
 14905 
 14906 /***********************************************************************
 14907                                Tool-bars
 14908  ***********************************************************************/
 14909 
 14910 #ifdef HAVE_WINDOW_SYSTEM
 14911 
 14912 /* Update the tool-bar item list for frame F.  This has to be done
 14913    before we start to fill in any display lines.  Called from
 14914    prepare_menu_bars.  If SAVE_MATCH_DATA, we must save
 14915    and restore it here.  */
 14916 
 14917 static void
 14918 update_tool_bar (struct frame *f, bool save_match_data)
 14919 {
 14920 #ifdef HAVE_EXT_TOOL_BAR
 14921   bool do_update = FRAME_EXTERNAL_TOOL_BAR (f);
 14922 #else
 14923   bool do_update = (WINDOWP (f->tool_bar_window)
 14924                     && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)) > 0);
 14925 #endif
 14926 
 14927   if (do_update)
 14928     {
 14929       Lisp_Object window;
 14930       struct window *w;
 14931 
 14932       window = FRAME_SELECTED_WINDOW (f);
 14933       w = XWINDOW (window);
 14934 
 14935       /* If the user has switched buffers or windows, we need to
 14936          recompute to reflect the new bindings.  But we'll
 14937          recompute when update_mode_lines is set too; that means
 14938          that people can use force-mode-line-update to request
 14939          that the menu bar be recomputed.  The adverse effect on
 14940          the rest of the redisplay algorithm is about the same as
 14941          windows_or_buffers_changed anyway.  */
 14942       if (windows_or_buffers_changed
 14943           || w->update_mode_line
 14944           || update_mode_lines
 14945           || window_buffer_changed (w))
 14946         {
 14947           struct buffer *prev = current_buffer;
 14948           specpdl_ref count = SPECPDL_INDEX ();
 14949           Lisp_Object frame, new_tool_bar;
 14950           int new_n_tool_bar;
 14951 
 14952           /* Set current_buffer to the buffer of the selected
 14953              window of the frame, so that we get the right local
 14954              keymaps.  */
 14955           set_buffer_internal_1 (XBUFFER (w->contents));
 14956 
 14957           /* Save match data, if we must.  */
 14958           if (save_match_data)
 14959             record_unwind_save_match_data ();
 14960 
 14961           /* Make sure that we don't accidentally use bogus keymaps.  */
 14962           if (NILP (Voverriding_local_map_menu_flag))
 14963             {
 14964               specbind (Qoverriding_terminal_local_map, Qnil);
 14965               specbind (Qoverriding_local_map, Qnil);
 14966             }
 14967 
 14968           /* We must temporarily set the selected frame to this frame
 14969              before calling tool_bar_items, because the calculation of
 14970              the tool-bar keymap uses the selected frame (see
 14971              `tool-bar-make-keymap' in tool-bar.el).  */
 14972           eassert (EQ (selected_window,
 14973                        /* Since we only explicitly preserve selected_frame,
 14974                           check that selected_window would be redundant.  */
 14975                        XFRAME (selected_frame)->selected_window));
 14976           record_unwind_protect (restore_selected_window, selected_window);
 14977           XSETFRAME (frame, f);
 14978           selected_frame = frame;
 14979           selected_window = FRAME_SELECTED_WINDOW (f);
 14980 
 14981           /* Build desired tool-bar items from keymaps.  */
 14982           new_tool_bar
 14983             = tool_bar_items (Fcopy_sequence (f->tool_bar_items),
 14984                               &new_n_tool_bar);
 14985 
 14986           /* Redisplay the tool-bar if we changed it.  */
 14987           if (new_n_tool_bar != f->n_tool_bar_items
 14988               || NILP (Fequal (new_tool_bar, f->tool_bar_items)))
 14989             {
 14990               /* Redisplay that happens asynchronously due to an expose event
 14991                  may access f->tool_bar_items.  Make sure we update both
 14992                  variables within BLOCK_INPUT so no such event interrupts.  */
 14993               block_input ();
 14994               fset_tool_bar_items (f, new_tool_bar);
 14995               f->n_tool_bar_items = new_n_tool_bar;
 14996               w->update_mode_line = true;
 14997               unblock_input ();
 14998             }
 14999 
 15000           unbind_to (count, Qnil);
 15001           set_buffer_internal_1 (prev);
 15002         }
 15003     }
 15004 }
 15005 
 15006 #ifndef HAVE_EXT_TOOL_BAR
 15007 
 15008 /* Set F->desired_tool_bar_string to a Lisp string representing frame
 15009    F's desired tool-bar contents.  F->tool_bar_items must have
 15010    been set up previously by calling prepare_menu_bars.
 15011 
 15012    Also set F->tool_bar_wraps_p to whether or not the tool bar
 15013    contains explicit line breaking items.  */
 15014 
 15015 static void
 15016 build_desired_tool_bar_string (struct frame *f)
 15017 {
 15018   int i, size, size_needed;
 15019   Lisp_Object image, plist;
 15020 
 15021   image = plist = Qnil;
 15022 
 15023   /* Prepare F->desired_tool_bar_string.  If we can reuse it, do so.
 15024      Otherwise, make a new string.  */
 15025 
 15026   /* The size of the string we might be able to reuse.  */
 15027   size = (STRINGP (f->desired_tool_bar_string)
 15028           ? SCHARS (f->desired_tool_bar_string)
 15029           : 0);
 15030 
 15031   /* We need one space in the string for each image.  */
 15032   size_needed = f->n_tool_bar_items;
 15033 
 15034   /* Reuse f->desired_tool_bar_string, if possible.  */
 15035 
 15036   if (size < size_needed || NILP (f->desired_tool_bar_string))
 15037     /* Don't initialize the contents of this string yet, as they will
 15038        be set within the loop below.  */
 15039     fset_desired_tool_bar_string (f, make_uninit_string (size_needed));
 15040   else
 15041     {
 15042       AUTO_LIST4 (props, Qdisplay, Qnil, Qmenu_item, Qnil);
 15043       Fremove_text_properties (make_fixnum (0), make_fixnum (size),
 15044                                props, f->desired_tool_bar_string);
 15045     }
 15046 
 15047   f->tool_bar_wraps_p = false;
 15048 
 15049   /* Put a `display' property on the string for the images to display,
 15050      put a `menu_item' property on tool-bar items with a value that
 15051      is the index of the item in F's tool-bar item vector.  */
 15052   for (i = 0; i < f->n_tool_bar_items; ++i)
 15053     {
 15054 #define PROP(IDX) \
 15055   AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
 15056 
 15057       bool enabled_p = !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P));
 15058       bool selected_p = !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P));
 15059       int hmargin, vmargin, relief, idx, end;
 15060 
 15061       if (!NILP (PROP (TOOL_BAR_ITEM_WRAP)))
 15062         {
 15063           /* This is a line wrap.  Instead of building a tool bar
 15064              item, display a new line character instead.  */
 15065           SSET (f->desired_tool_bar_string, i, '\n');
 15066 
 15067           /* Set F->tool_bar_wraps_p.  This tells redisplay_tool_bar
 15068              to allow individual rows to be different heights.  */
 15069           f->tool_bar_wraps_p = true;
 15070           continue;
 15071         }
 15072 
 15073       /* Replace this with a space character.  */
 15074       SSET (f->desired_tool_bar_string, i, ' ');
 15075 
 15076       /* If image is a vector, choose the image according to the
 15077          button state.  */
 15078       image = PROP (TOOL_BAR_ITEM_IMAGES);
 15079       if (VECTORP (image))
 15080         {
 15081           if (enabled_p)
 15082             idx = (selected_p
 15083                    ? TOOL_BAR_IMAGE_ENABLED_SELECTED
 15084                    : TOOL_BAR_IMAGE_ENABLED_DESELECTED);
 15085           else
 15086             idx = (selected_p
 15087                    ? TOOL_BAR_IMAGE_DISABLED_SELECTED
 15088                    : TOOL_BAR_IMAGE_DISABLED_DESELECTED);
 15089 
 15090           eassert (ASIZE (image) >= idx);
 15091           image = AREF (image, idx);
 15092         }
 15093       else
 15094         idx = -1;
 15095 
 15096       /* Ignore invalid image specifications.  */
 15097       if (!valid_image_p (image))
 15098         continue;
 15099 
 15100       /* Display the tool-bar button pressed, or depressed.  */
 15101       plist = Fcopy_sequence (XCDR (image));
 15102 
 15103       /* Compute margin and relief to draw.  */
 15104       relief = (tool_bar_button_relief >= 0
 15105                 ? min (tool_bar_button_relief,
 15106                        min (INT_MAX, MOST_POSITIVE_FIXNUM))
 15107                 : DEFAULT_TOOL_BAR_BUTTON_RELIEF);
 15108       hmargin = vmargin = relief;
 15109 
 15110       if (RANGED_FIXNUMP (1, Vtool_bar_button_margin,
 15111                            INT_MAX - max (hmargin, vmargin)))
 15112         {
 15113           hmargin += XFIXNAT (Vtool_bar_button_margin);
 15114           vmargin += XFIXNAT (Vtool_bar_button_margin);
 15115         }
 15116       else if (CONSP (Vtool_bar_button_margin))
 15117         {
 15118           if (RANGED_FIXNUMP (1, XCAR (Vtool_bar_button_margin),
 15119                                INT_MAX - hmargin))
 15120             hmargin += XFIXNAT (XCAR (Vtool_bar_button_margin));
 15121 
 15122           if (RANGED_FIXNUMP (1, XCDR (Vtool_bar_button_margin),
 15123                                INT_MAX - vmargin))
 15124             vmargin += XFIXNAT (XCDR (Vtool_bar_button_margin));
 15125         }
 15126 
 15127       if (auto_raise_tool_bar_buttons_p)
 15128         {
 15129           /* Add a `:relief' property to the image spec if the item is
 15130              selected.  */
 15131           if (selected_p)
 15132             {
 15133               plist = plist_put (plist, QCrelief, make_fixnum (-relief));
 15134               hmargin -= relief;
 15135               vmargin -= relief;
 15136             }
 15137         }
 15138       else
 15139         {
 15140           /* If image is selected, display it pressed, i.e. with a
 15141              negative relief.  If it's not selected, display it with a
 15142              raised relief.  */
 15143           plist = plist_put (plist, QCrelief,
 15144                              (selected_p
 15145                               ? make_fixnum (-relief)
 15146                               : make_fixnum (relief)));
 15147           hmargin -= relief;
 15148           vmargin -= relief;
 15149         }
 15150 
 15151       /* Put a margin around the image.  */
 15152       if (hmargin || vmargin)
 15153         {
 15154           if (hmargin == vmargin)
 15155             plist = plist_put (plist, QCmargin, make_fixnum (hmargin));
 15156           else
 15157             plist = plist_put (plist, QCmargin,
 15158                                Fcons (make_fixnum (hmargin),
 15159                                       make_fixnum (vmargin)));
 15160         }
 15161 
 15162       /* If button is not enabled, and we don't have special images
 15163          for the disabled state, make the image appear disabled by
 15164          applying an appropriate algorithm to it.  */
 15165       if (!enabled_p && idx < 0)
 15166         plist = plist_put (plist, QCconversion, Qdisabled);
 15167 
 15168       /* Put a `display' text property on the string for the image to
 15169          display.  Put a `menu-item' property on the string that gives
 15170          the start of this item's properties in the tool-bar items
 15171          vector.  */
 15172       image = Fcons (Qimage, plist);
 15173       AUTO_LIST4 (props, Qdisplay, image, Qmenu_item,
 15174                   make_fixnum (i * TOOL_BAR_ITEM_NSLOTS));
 15175 
 15176       /* Let the last image hide all remaining spaces in the tool bar
 15177          string.  The string can be longer than needed when we reuse a
 15178          previous string.  */
 15179       if (i + 1 == f->n_tool_bar_items)
 15180         end = SCHARS (f->desired_tool_bar_string);
 15181       else
 15182         end = i + 1;
 15183       Fadd_text_properties (make_fixnum (i), make_fixnum (end),
 15184                             props, f->desired_tool_bar_string);
 15185 #undef PROP
 15186     }
 15187 
 15188   /* Now replace each character between i and the end of the tool bar
 15189      string with spaces, to prevent stray newlines from accumulating
 15190      when the number of tool bar items decreases.  `size' is 0 if the
 15191      tool bar string is new, but in that case the string will have
 15192      been completely initialized anyway.  */
 15193 
 15194   for (; i < size; ++i)
 15195     /* Replace this with a space character.  */
 15196     SSET (f->desired_tool_bar_string, i, ' ');
 15197 }
 15198 
 15199 
 15200 /* Display one line of the tool-bar of frame IT->f.
 15201 
 15202    HEIGHT specifies the desired height of the tool-bar line.
 15203    If the actual height of the glyph row is less than HEIGHT, the
 15204    row's height is increased to HEIGHT, and the icons are centered
 15205    vertically in the new height.
 15206 
 15207    If HEIGHT is -1, we are counting needed tool-bar lines, so don't
 15208    count a final empty row in case the tool-bar width exactly matches
 15209    the window width.
 15210 
 15211    HEIGHT may also be -1 if there is an explicit line wrapping item
 15212    inside the tool bar; in that case, allow individual rows of the
 15213    tool bar to differ in height.  */
 15214 
 15215 static void
 15216 display_tool_bar_line (struct it *it, int height)
 15217 {
 15218   struct glyph_row *row = it->glyph_row;
 15219   int max_x = it->last_visible_x;
 15220   struct glyph *last;
 15221 
 15222   /* Don't extend on a previously drawn tool bar items (Bug#16058).  */
 15223   clear_glyph_row (row);
 15224   row->enabled_p = true;
 15225   row->y = it->current_y;
 15226 
 15227   /* Note that this isn't made use of if the face hasn't a box,
 15228      so there's no need to check the face here.  */
 15229   it->start_of_box_run_p = true;
 15230 
 15231   while (it->current_x < max_x)
 15232     {
 15233       int x, n_glyphs_before, i, nglyphs;
 15234       struct it it_before;
 15235 
 15236       /* Get the next display element.  */
 15237       if (!get_next_display_element (it))
 15238         {
 15239           /* Don't count empty row if we are counting needed tool-bar lines.  */
 15240           if (height < 0 && !it->hpos)
 15241             return;
 15242           break;
 15243         }
 15244 
 15245       /* Produce glyphs.  */
 15246       n_glyphs_before = row->used[TEXT_AREA];
 15247       it_before = *it;
 15248 
 15249       PRODUCE_GLYPHS (it);
 15250 
 15251       nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
 15252       i = 0;
 15253       x = it_before.current_x;
 15254       while (i < nglyphs)
 15255         {
 15256           struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
 15257 
 15258           if (x + glyph->pixel_width > max_x)
 15259             {
 15260               /* Glyph doesn't fit on line.  Backtrack.  */
 15261               row->used[TEXT_AREA] = n_glyphs_before;
 15262               *it = it_before;
 15263               /* If this is the only glyph on this line, it will never fit on the
 15264                  tool-bar, so skip it.  But ensure there is at least one glyph,
 15265                  so we don't accidentally disable the tool-bar.  */
 15266               if (n_glyphs_before == 0
 15267                   && (it->vpos > 0 || IT_STRING_CHARPOS (*it) < it->end_charpos-1))
 15268                 break;
 15269               goto out;
 15270             }
 15271 
 15272           ++it->hpos;
 15273           x += glyph->pixel_width;
 15274           ++i;
 15275         }
 15276 
 15277       /* Stop at the end of the iterator, and move to the next line
 15278          upon a '\n' appearing in the tool bar string.  Tool bar
 15279          strings may contain multiple new line characters when
 15280          explicit wrap items are encountered.  */
 15281 
 15282       if (ITERATOR_AT_END_OF_LINE_P (it))
 15283         {
 15284           reseat_at_next_visible_line_start (it, false);
 15285           break;
 15286         }
 15287 
 15288       if (ITERATOR_AT_END_P (it))
 15289         break;
 15290 
 15291       set_iterator_to_next (it, true);
 15292     }
 15293 
 15294  out:;
 15295 
 15296   row->displays_text_p = row->used[TEXT_AREA] != 0;
 15297 
 15298   /* Use default face for the border below the tool bar.
 15299 
 15300      FIXME: When auto-resize-tool-bars is grow-only, there is
 15301      no additional border below the possibly empty tool-bar lines.
 15302      So to make the extra empty lines look "normal", we have to
 15303      use the tool-bar face for the border too.  */
 15304   if (!MATRIX_ROW_DISPLAYS_TEXT_P (row)
 15305       && !EQ (Vauto_resize_tool_bars, Qgrow_only))
 15306     it->face_id = DEFAULT_FACE_ID;
 15307 
 15308   extend_face_to_end_of_line (it);
 15309   last = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
 15310   last->right_box_line_p = true;
 15311   if (last == row->glyphs[TEXT_AREA])
 15312     last->left_box_line_p = true;
 15313 
 15314   /* Make line the desired height and center it vertically.  */
 15315   if (height != -1
 15316       && (height -= it->max_ascent + it->max_descent) > 0)
 15317     {
 15318       /* Don't add more than one line height.  */
 15319       height %= FRAME_LINE_HEIGHT (it->f);
 15320       it->max_ascent += height / 2;
 15321       it->max_descent += (height + 1) / 2;
 15322     }
 15323 
 15324   compute_line_metrics (it);
 15325 
 15326   /* If line is empty, make it occupy the rest of the tool-bar.  */
 15327   if (!MATRIX_ROW_DISPLAYS_TEXT_P (row))
 15328     {
 15329       row->height = row->phys_height = it->last_visible_y - row->y;
 15330       row->visible_height = row->height;
 15331       row->ascent = row->phys_ascent = 0;
 15332       row->extra_line_spacing = 0;
 15333     }
 15334 
 15335   row->full_width_p = true;
 15336   row->continued_p = false;
 15337   row->truncated_on_left_p = false;
 15338   row->truncated_on_right_p = false;
 15339 
 15340   it->current_x = it->hpos = 0;
 15341   it->current_y += row->height;
 15342   ++it->vpos;
 15343   ++it->glyph_row;
 15344 }
 15345 
 15346 
 15347 /* Value is the number of pixels needed to make all tool-bar items of
 15348    frame F visible.  The actual number of glyph rows needed is
 15349    returned in *N_ROWS if non-NULL.  */
 15350 
 15351 static int
 15352 tool_bar_height (struct frame *f, int *n_rows, bool pixelwise)
 15353 {
 15354   struct window *w = XWINDOW (f->tool_bar_window);
 15355   struct it it;
 15356   /* tool_bar_height is called from redisplay_tool_bar after building
 15357      the desired matrix, so use (unused) mode-line row as temporary row to
 15358      avoid destroying the first tool-bar row.  */
 15359   struct glyph_row *temp_row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
 15360 
 15361   /* Initialize an iterator for iteration over
 15362      F->desired_tool_bar_string in the tool-bar window of frame F.  */
 15363   init_iterator (&it, w, -1, -1, temp_row, TOOL_BAR_FACE_ID);
 15364   temp_row->reversed_p = false;
 15365   it.first_visible_x = 0;
 15366   it.last_visible_x = WINDOW_PIXEL_WIDTH (w);
 15367   reseat_to_string (&it, NULL, f->desired_tool_bar_string,
 15368                     0, 0, 0, STRING_MULTIBYTE (f->desired_tool_bar_string));
 15369   it.paragraph_embedding = L2R;
 15370 
 15371   while (!ITERATOR_AT_END_P (&it))
 15372     {
 15373       clear_glyph_row (temp_row);
 15374       it.glyph_row = temp_row;
 15375       display_tool_bar_line (&it, -1);
 15376     }
 15377   clear_glyph_row (temp_row);
 15378 
 15379   /* f->n_tool_bar_rows == 0 means "unknown"; -1 means no tool-bar.  */
 15380   if (n_rows)
 15381     *n_rows = it.vpos > 0 ? it.vpos : -1;
 15382 
 15383   if (pixelwise)
 15384     return it.current_y;
 15385   else
 15386     return (it.current_y + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
 15387 }
 15388 
 15389 #endif /* ! (HAVE_EXT_TOOL_BAR) */
 15390 
 15391 DEFUN ("tool-bar-height", Ftool_bar_height, Stool_bar_height,
 15392        0, 2, 0,
 15393        doc: /* Return the number of lines occupied by the tool bar of FRAME.
 15394 If FRAME is nil or omitted, use the selected frame.  Optional argument
 15395 PIXELWISE non-nil means return the height of the tool bar in pixels.  */)
 15396   (Lisp_Object frame, Lisp_Object pixelwise)
 15397 {
 15398   int height = 0;
 15399 
 15400 #ifndef HAVE_EXT_TOOL_BAR
 15401   struct frame *f = decode_any_frame (frame);
 15402 
 15403   if (WINDOWP (f->tool_bar_window)
 15404       && WINDOW_PIXEL_HEIGHT (XWINDOW (f->tool_bar_window)) > 0)
 15405     {
 15406       update_tool_bar (f, true);
 15407       if (f->n_tool_bar_items)
 15408         {
 15409           build_desired_tool_bar_string (f);
 15410           height = tool_bar_height (f, NULL, !NILP (pixelwise));
 15411         }
 15412     }
 15413 #endif
 15414 
 15415   return make_fixnum (height);
 15416 }
 15417 
 15418 #ifndef HAVE_EXT_TOOL_BAR
 15419 
 15420 /* Display the internal tool-bar of frame F.  Value is true if
 15421    tool-bar's height should be changed.  */
 15422 static bool
 15423 redisplay_tool_bar (struct frame *f)
 15424 {
 15425   struct window *w;
 15426   struct it it;
 15427   struct glyph_row *row;
 15428   bool change_height_p;
 15429 
 15430   change_height_p = false;
 15431   f->tool_bar_redisplayed = true;
 15432 
 15433   /* If frame hasn't a tool-bar window or if it is zero-height, don't
 15434      do anything.  This means you must start with tool-bar-lines
 15435      non-zero to get the auto-sizing effect.  Or in other words, you
 15436      can turn off tool-bars by specifying tool-bar-lines zero.  */
 15437   if (!WINDOWP (f->tool_bar_window)
 15438       || (w = XWINDOW (f->tool_bar_window),
 15439           WINDOW_TOTAL_LINES (w) == 0))
 15440     {
 15441       /* Even if we do not display a tool bar initially, still pretend
 15442          that we have resized it already.  This avoids that a later
 15443          activation of the tool bar resizes the frame, despite of the
 15444          fact that a setting of 'frame-inhibit-implied-resize' should
 15445          inhibit it (Bug#52986).  */
 15446       f->tool_bar_resized = true;
 15447 
 15448       return false;
 15449     }
 15450 
 15451   /* Set up an iterator for the tool-bar window.  */
 15452   init_iterator (&it, w, -1, -1, w->desired_matrix->rows, TOOL_BAR_FACE_ID);
 15453   it.first_visible_x = 0;
 15454   it.last_visible_x = WINDOW_PIXEL_WIDTH (w);
 15455   row = it.glyph_row;
 15456   row->reversed_p = false;
 15457 
 15458   /* Build a string that represents the contents of the tool-bar.  */
 15459   build_desired_tool_bar_string (f);
 15460   reseat_to_string (&it, NULL, f->desired_tool_bar_string,
 15461                     0, 0, 0, STRING_MULTIBYTE (f->desired_tool_bar_string));
 15462   /* FIXME: This should be controlled by a user option.  But it
 15463      doesn't make sense to have an R2L tool bar if the menu bar cannot
 15464      be drawn also R2L, and making the menu bar R2L is tricky due to
 15465      toolkit-specific code that implements it.  If an R2L tool bar is
 15466      ever supported, display_tool_bar_line should also be augmented to
 15467      call unproduce_glyphs like display_line and display_string
 15468      do.  */
 15469   it.paragraph_embedding = L2R;
 15470 
 15471   if (f->n_tool_bar_rows == 0)
 15472     {
 15473       int new_height = tool_bar_height (f, &f->n_tool_bar_rows, true);
 15474 
 15475       if (new_height != WINDOW_PIXEL_HEIGHT (w))
 15476         {
 15477           if (FRAME_TERMINAL (f)->change_tool_bar_height_hook)
 15478             FRAME_TERMINAL (f)->change_tool_bar_height_hook (f, new_height);
 15479           frame_default_tool_bar_height = new_height;
 15480           /* Always do that now.  */
 15481           clear_glyph_matrix (w->desired_matrix);
 15482           f->fonts_changed = true;
 15483 
 15484           /* Kludge (this applies to the X Windows version as well as
 15485              Android): when the tool bar size changes,
 15486              adjust_window_size (presumably called by
 15487              change_tool_bar_height_hook) does not call through to
 15488              resize_frame_windows.  Pending further investigation,
 15489              just call it here as well.  */
 15490           resize_frame_windows (f, FRAME_INNER_HEIGHT (f), false);
 15491 
 15492           return true;
 15493         }
 15494     }
 15495 
 15496   /* Display as many lines as needed to display all tool-bar items.  */
 15497 
 15498   if (f->n_tool_bar_rows > 0)
 15499     {
 15500       int border, rows, height, extra;
 15501 
 15502       if (TYPE_RANGED_FIXNUMP (int, Vtool_bar_border))
 15503         border = XFIXNUM (Vtool_bar_border);
 15504       else if (EQ (Vtool_bar_border, Qinternal_border_width))
 15505         border = FRAME_INTERNAL_BORDER_WIDTH (f);
 15506       else if (EQ (Vtool_bar_border, Qborder_width))
 15507         border = f->border_width;
 15508       else
 15509         border = 0;
 15510       if (border < 0)
 15511         border = 0;
 15512 
 15513       rows = f->n_tool_bar_rows;
 15514 
 15515       if (f->tool_bar_wraps_p)
 15516         {
 15517           /* If the tool bar contains explicit line wrapping items,
 15518              don't force each row to have a fixed height.  */
 15519 
 15520           while (!ITERATOR_AT_END_P (&it))
 15521             display_tool_bar_line (&it, -1);
 15522 
 15523           /* Because changes to individual tool bar items may now
 15524              change the height of the tool bar, adjust the height of
 15525              the tool bar window if it is different from the tool bar
 15526              height in any way.  */
 15527 
 15528           if (it.current_y != it.last_visible_y)
 15529             change_height_p = true;
 15530         }
 15531       else
 15532         {
 15533           height = max (1, (it.last_visible_y - border) / rows);
 15534           extra = it.last_visible_y - border - height * rows;
 15535 
 15536           while (it.current_y < it.last_visible_y)
 15537             {
 15538               int h = 0;
 15539               if (extra > 0 && rows-- > 0)
 15540                 {
 15541                   h = (extra + rows - 1) / rows;
 15542                   extra -= h;
 15543                 }
 15544           
 15545               display_tool_bar_line (&it, height + h);
 15546             }
 15547         }
 15548     }
 15549   else
 15550     {
 15551       while (it.current_y < it.last_visible_y)
 15552         display_tool_bar_line (&it, 0);
 15553     }
 15554 
 15555   /* It doesn't make much sense to try scrolling in the tool-bar
 15556      window, so don't do it.  */
 15557   w->desired_matrix->no_scrolling_p = true;
 15558   w->must_be_updated_p = true;
 15559 
 15560   if (!NILP (Vauto_resize_tool_bars))
 15561     {
 15562       /* If we couldn't display everything, change the tool-bar's
 15563          height if there is room for more.  */
 15564       if (IT_STRING_CHARPOS (it) < it.end_charpos)
 15565         change_height_p = true;
 15566 
 15567       /* We subtract 1 because display_tool_bar_line advances the
 15568          glyph_row pointer before returning to its caller.  We want to
 15569          examine the last glyph row produced by
 15570          display_tool_bar_line.  */
 15571       row = it.glyph_row - 1;
 15572 
 15573       /* If there are blank lines at the end, except for a partially
 15574          visible blank line at the end that is smaller than
 15575          FRAME_LINE_HEIGHT, change the tool-bar's height.  */
 15576       if (!MATRIX_ROW_DISPLAYS_TEXT_P (row)
 15577           && row->height >= FRAME_LINE_HEIGHT (f))
 15578         change_height_p = true;
 15579 
 15580       /* If row displays tool-bar items, but is partially visible,
 15581          change the tool-bar's height.  */
 15582       if (MATRIX_ROW_DISPLAYS_TEXT_P (row)
 15583           && MATRIX_ROW_BOTTOM_Y (row) > it.last_visible_y)
 15584         change_height_p = true;
 15585 
 15586       /* Resize windows as needed by changing the `tool-bar-lines'
 15587          frame parameter.  */
 15588       if (change_height_p)
 15589         {
 15590           int nrows;
 15591           int new_height = tool_bar_height (f, &nrows, true);
 15592 
 15593           change_height_p = ((EQ (Vauto_resize_tool_bars, Qgrow_only)
 15594                               && !f->minimize_tool_bar_window_p)
 15595                              ? (new_height > WINDOW_PIXEL_HEIGHT (w))
 15596                              : (new_height != WINDOW_PIXEL_HEIGHT (w)));
 15597           f->minimize_tool_bar_window_p = false;
 15598 
 15599           if (change_height_p)
 15600             {
 15601               if (FRAME_TERMINAL (f)->change_tool_bar_height_hook)
 15602                 FRAME_TERMINAL (f)->change_tool_bar_height_hook (f, new_height);
 15603               frame_default_tool_bar_height = new_height;
 15604               clear_glyph_matrix (w->desired_matrix);
 15605               f->n_tool_bar_rows = nrows;
 15606               f->fonts_changed = true;
 15607 
 15608               return true;
 15609             }
 15610         }
 15611     }
 15612 
 15613   f->minimize_tool_bar_window_p = false;
 15614 
 15615   return false;
 15616 }
 15617 
 15618 /* Get information about the tool-bar item which is displayed in GLYPH
 15619    on frame F.  Return in *PROP_IDX the index where tool-bar item
 15620    properties start in F->tool_bar_items.  Value is false if
 15621    GLYPH doesn't display a tool-bar item.  */
 15622 
 15623 static bool
 15624 tool_bar_item_info (struct frame *f, struct glyph *glyph, int *prop_idx)
 15625 {
 15626   Lisp_Object prop;
 15627   ptrdiff_t charpos;
 15628 
 15629   /* This function can be called asynchronously, which means we must
 15630      exclude any possibility that Fget_text_property signals an
 15631      error.  */
 15632   charpos = min (SCHARS (f->current_tool_bar_string), glyph->charpos);
 15633   charpos = max (0, charpos);
 15634 
 15635   /* Get the text property `menu-item' at pos. The value of that
 15636      property is the start index of this item's properties in
 15637      F->tool_bar_items.  */
 15638   prop = Fget_text_property (make_fixnum (charpos),
 15639                              Qmenu_item, f->current_tool_bar_string);
 15640   if (! FIXNUMP (prop))
 15641     return false;
 15642   *prop_idx = XFIXNUM (prop);
 15643   return true;
 15644 }
 15645 
 15646 
 15647 /* Get information about the tool-bar item at position X/Y on frame F.
 15648    Return in *GLYPH a pointer to the glyph of the tool-bar item in
 15649    the current matrix of the tool-bar window of F, or NULL if not
 15650    on a tool-bar item.  Return in *PROP_IDX the index of the tool-bar
 15651    item in F->tool_bar_items.  Value is
 15652 
 15653    -1   if X/Y is not on a tool-bar item
 15654    0    if X/Y is on the same item that was highlighted before.
 15655    1    otherwise.  */
 15656 
 15657 static int
 15658 get_tool_bar_item (struct frame *f, int x, int y, struct glyph **glyph,
 15659                    int *hpos, int *vpos, int *prop_idx)
 15660 {
 15661   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 15662   struct window *w = XWINDOW (f->tool_bar_window);
 15663   int area;
 15664 
 15665   /* Find the glyph under X/Y.  */
 15666   *glyph = x_y_to_hpos_vpos (w, x, y, hpos, vpos, 0, 0, &area);
 15667   if (*glyph == NULL)
 15668     return -1;
 15669 
 15670   /* Get the start of this tool-bar item's properties in
 15671      f->tool_bar_items.  */
 15672   if (!tool_bar_item_info (f, *glyph, prop_idx))
 15673     return -1;
 15674 
 15675   /* Is mouse on the highlighted item?  */
 15676   if (EQ (f->tool_bar_window, hlinfo->mouse_face_window)
 15677       && *vpos >= hlinfo->mouse_face_beg_row
 15678       && *vpos <= hlinfo->mouse_face_end_row
 15679       && (*vpos > hlinfo->mouse_face_beg_row
 15680           || *hpos >= hlinfo->mouse_face_beg_col)
 15681       && (*vpos < hlinfo->mouse_face_end_row
 15682           || *hpos < hlinfo->mouse_face_end_col
 15683           || hlinfo->mouse_face_past_end))
 15684     return 0;
 15685 
 15686   return 1;
 15687 }
 15688 
 15689 
 15690 /* EXPORT:
 15691    Handle mouse button event on the tool-bar of frame F, at
 15692    frame-relative coordinates X/Y.  DOWN_P is true for a button press,
 15693    false for button release.  MODIFIERS is event modifiers for button
 15694    release.  DEVICE is the device the click came from, or Qt.  */
 15695 
 15696 void
 15697 handle_tool_bar_click_with_device (struct frame *f, int x, int y, bool down_p,
 15698                                    int modifiers, Lisp_Object device)
 15699 {
 15700   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 15701   struct window *w = XWINDOW (f->tool_bar_window);
 15702   int hpos, vpos, prop_idx;
 15703   struct glyph *glyph;
 15704   Lisp_Object enabled_p;
 15705   int ts;
 15706 
 15707   /* If not on the highlighted tool-bar item, and mouse-highlight is
 15708      non-nil, return.  This is so we generate the tool-bar button
 15709      click only when the mouse button is released on the same item as
 15710      where it was pressed.  However, when mouse-highlight is disabled,
 15711      generate the click when the button is released regardless of the
 15712      highlight, since tool-bar items are not highlighted in that
 15713      case.  */
 15714   frame_to_window_pixel_xy (w, &x, &y);
 15715   ts = get_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx);
 15716   if (ts == -1
 15717       || (ts != 0 && !NILP (Vmouse_highlight)))
 15718     return;
 15719 
 15720   /* When mouse-highlight is off, generate the click for the item
 15721      where the button was pressed, disregarding where it was
 15722      released.  */
 15723   if (NILP (Vmouse_highlight) && !down_p)
 15724     prop_idx = f->last_tool_bar_item;
 15725 
 15726   /* If item is disabled, do nothing.  */
 15727   enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
 15728   if (NILP (enabled_p))
 15729     return;
 15730 
 15731   if (down_p)
 15732     {
 15733       /* Show item in pressed state.  */
 15734       if (!NILP (Vmouse_highlight))
 15735         show_mouse_face (hlinfo, DRAW_IMAGE_SUNKEN);
 15736       f->last_tool_bar_item = prop_idx;
 15737     }
 15738   else
 15739     {
 15740       Lisp_Object key, frame;
 15741       struct input_event event;
 15742       EVENT_INIT (event);
 15743 
 15744       /* Show item in released state.  */
 15745       if (!NILP (Vmouse_highlight))
 15746         show_mouse_face (hlinfo, DRAW_IMAGE_RAISED);
 15747 
 15748       key = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_KEY);
 15749 
 15750       XSETFRAME (frame, f);
 15751       event.kind = TOOL_BAR_EVENT;
 15752       event.frame_or_window = frame;
 15753       event.arg = key;
 15754       event.modifiers = modifiers;
 15755       event.device = device;
 15756       kbd_buffer_store_event (&event);
 15757       f->last_tool_bar_item = -1;
 15758     }
 15759 }
 15760 
 15761 void
 15762 handle_tool_bar_click (struct frame *f, int x, int y, bool down_p,
 15763                        int modifiers)
 15764 {
 15765   handle_tool_bar_click_with_device (f, x, y, down_p, modifiers, Qt);
 15766 }
 15767 
 15768 /* Possibly highlight a tool-bar item on frame F when mouse moves to
 15769    tool-bar window-relative coordinates X/Y.  Called from
 15770    note_mouse_highlight.  */
 15771 
 15772 static void
 15773 note_tool_bar_highlight (struct frame *f, int x, int y)
 15774 {
 15775   Lisp_Object window = f->tool_bar_window;
 15776   struct window *w = XWINDOW (window);
 15777   Display_Info *dpyinfo = FRAME_DISPLAY_INFO (f);
 15778   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 15779   int hpos, vpos;
 15780   struct glyph *glyph;
 15781   struct glyph_row *row;
 15782   int i;
 15783   Lisp_Object enabled_p;
 15784   int prop_idx;
 15785   enum draw_glyphs_face draw = DRAW_IMAGE_RAISED;
 15786   bool mouse_down_p;
 15787   int rc;
 15788 
 15789   /* Function note_mouse_highlight is called with negative X/Y
 15790      values when mouse moves outside of the frame.  */
 15791   if (x <= 0 || y <= 0)
 15792     {
 15793       clear_mouse_face (hlinfo);
 15794       return;
 15795     }
 15796 
 15797   rc = get_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx);
 15798   if (rc < 0)
 15799     {
 15800       /* Not on tool-bar item.  */
 15801       clear_mouse_face (hlinfo);
 15802       return;
 15803     }
 15804   else if (rc == 0)
 15805     /* On same tool-bar item as before.  */
 15806     goto set_help_echo;
 15807 
 15808   clear_mouse_face (hlinfo);
 15809 
 15810   /* Mouse is down, but on different tool-bar item?  */
 15811   mouse_down_p = (gui_mouse_grabbed (dpyinfo)
 15812                   && f == dpyinfo->last_mouse_frame);
 15813 
 15814   if (mouse_down_p && f->last_tool_bar_item != prop_idx)
 15815     return;
 15816 
 15817   draw = mouse_down_p ? DRAW_IMAGE_SUNKEN : DRAW_IMAGE_RAISED;
 15818 
 15819   /* If tool-bar item is not enabled, don't highlight it.  */
 15820   enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
 15821   if (!NILP (enabled_p) && !NILP (Vmouse_highlight))
 15822     {
 15823       /* Compute the x-position of the glyph.  In front and past the
 15824          image is a space.  We include this in the highlighted area.  */
 15825       row = MATRIX_ROW (w->current_matrix, vpos);
 15826       for (i = x = 0; i < hpos; ++i)
 15827         x += row->glyphs[TEXT_AREA][i].pixel_width;
 15828 
 15829       /* Record this as the current active region.  */
 15830       hlinfo->mouse_face_beg_col = hpos;
 15831       hlinfo->mouse_face_beg_row = vpos;
 15832       hlinfo->mouse_face_beg_x = x;
 15833       hlinfo->mouse_face_past_end = false;
 15834 
 15835       hlinfo->mouse_face_end_col = hpos + 1;
 15836       hlinfo->mouse_face_end_row = vpos;
 15837       hlinfo->mouse_face_end_x = x + glyph->pixel_width;
 15838       hlinfo->mouse_face_window = window;
 15839       hlinfo->mouse_face_face_id = TOOL_BAR_FACE_ID;
 15840 
 15841       /* Display it as active.  */
 15842       show_mouse_face (hlinfo, draw);
 15843     }
 15844 
 15845  set_help_echo:
 15846 
 15847   /* Set help_echo_string to a help string to display for this tool-bar item.
 15848      XTread_socket does the rest.  */
 15849   help_echo_object = help_echo_window = Qnil;
 15850   help_echo_pos = -1;
 15851   help_echo_string = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_HELP);
 15852   if (NILP (help_echo_string))
 15853     help_echo_string = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_CAPTION);
 15854 }
 15855 
 15856 #endif /* ! (HAVE_EXT_TOOL_BAR) */
 15857 
 15858 #endif /* HAVE_WINDOW_SYSTEM */
 15859 
 15860 
 15861 
 15862 /************************************************************************
 15863                          Horizontal scrolling
 15864  ************************************************************************/
 15865 
 15866 /* For all leaf windows in the window tree rooted at WINDOW, set their
 15867    hscroll value so that PT is (i) visible in the window, and (ii) so
 15868    that it is not within a certain margin at the window's left and
 15869    right border.  Value is true if any window's hscroll has been
 15870    changed.  */
 15871 
 15872 static bool
 15873 hscroll_window_tree (Lisp_Object window)
 15874 {
 15875   bool hscrolled_p = false;
 15876   bool hscroll_relative_p = FLOATP (Vhscroll_step);
 15877   int hscroll_step_abs = 0;
 15878   double hscroll_step_rel = 0;
 15879 
 15880   if (hscroll_relative_p)
 15881     {
 15882       hscroll_step_rel = XFLOAT_DATA (Vhscroll_step);
 15883       if (hscroll_step_rel < 0)
 15884         {
 15885           hscroll_relative_p = false;
 15886           hscroll_step_abs = 0;
 15887         }
 15888     }
 15889   else if (TYPE_RANGED_FIXNUMP (int, Vhscroll_step))
 15890     {
 15891       hscroll_step_abs = XFIXNUM (Vhscroll_step);
 15892       if (hscroll_step_abs < 0)
 15893         hscroll_step_abs = 0;
 15894     }
 15895   else
 15896     hscroll_step_abs = 0;
 15897 
 15898   while (WINDOWP (window))
 15899     {
 15900       struct window *w = XWINDOW (window);
 15901 
 15902       if (WINDOWP (w->contents))
 15903         hscrolled_p |= hscroll_window_tree (w->contents);
 15904       else if (w->cursor.vpos >= 0
 15905                /* Don't allow hscroll in mini-windows that display
 15906                   echo-area messages.  This is because desired_matrix
 15907                   of such windows was prepared while momentarily
 15908                   switched to an echo-area buffer, which is different
 15909                   from w->contents, and we simply cannot hscroll such
 15910                   windows safely.  */
 15911                && !(w == XWINDOW (echo_area_window)
 15912                     && !NILP (echo_area_buffer[0])))
 15913         {
 15914           int h_margin;
 15915           int text_area_width;
 15916           struct glyph_row *cursor_row;
 15917           struct glyph_row *bottom_row;
 15918 
 15919           bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->desired_matrix, w);
 15920           if (w->cursor.vpos < bottom_row - w->desired_matrix->rows)
 15921             cursor_row = MATRIX_ROW (w->desired_matrix, w->cursor.vpos);
 15922           else
 15923             cursor_row = bottom_row - 1;
 15924 
 15925           if (!cursor_row->enabled_p)
 15926             {
 15927               bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
 15928               if (w->cursor.vpos < bottom_row - w->current_matrix->rows)
 15929                 cursor_row = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
 15930               else
 15931                 cursor_row = bottom_row - 1;
 15932             }
 15933           bool row_r2l_p = cursor_row->reversed_p;
 15934           bool hscl = hscrolling_current_line_p (w);
 15935           int x_offset = 0;
 15936           /* When line numbers are displayed, we need to account for
 15937              the horizontal space they consume.  */
 15938           if (!NILP (Vdisplay_line_numbers))
 15939             {
 15940               struct glyph *g;
 15941               if (!row_r2l_p)
 15942                 {
 15943                   for (g = cursor_row->glyphs[TEXT_AREA];
 15944                        g < cursor_row->glyphs[TEXT_AREA]
 15945                          + cursor_row->used[TEXT_AREA];
 15946                        g++)
 15947                     {
 15948                       if (!(NILP (g->object) && g->charpos < 0))
 15949                         break;
 15950                       x_offset += g->pixel_width;
 15951                     }
 15952                 }
 15953               else
 15954                 {
 15955                   for (g = cursor_row->glyphs[TEXT_AREA]
 15956                          + cursor_row->used[TEXT_AREA];
 15957                        g > cursor_row->glyphs[TEXT_AREA];
 15958                        g--)
 15959                     {
 15960                       if (!(NILP ((g - 1)->object) && (g - 1)->charpos < 0))
 15961                         break;
 15962                       x_offset += (g - 1)->pixel_width;
 15963                     }
 15964                 }
 15965             }
 15966           if (cursor_row->truncated_on_left_p)
 15967             {
 15968               /* On TTY frames, don't count the left truncation glyph.  */
 15969               struct frame *f = XFRAME (WINDOW_FRAME (w));
 15970               x_offset -= (FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f));
 15971             }
 15972 
 15973           text_area_width = window_box_width (w, TEXT_AREA);
 15974 
 15975           /* Scroll when cursor is inside this scroll margin.  */
 15976           h_margin = (clip_to_bounds (0, hscroll_margin, 1000000)
 15977                       * WINDOW_FRAME_COLUMN_WIDTH (w));
 15978 
 15979           /* If the position of this window's point has explicitly
 15980              changed, no more suspend auto hscrolling.  */
 15981           if (w->suspend_auto_hscroll
 15982               && NILP (Fequal (Fwindow_point (window),
 15983                                Fwindow_old_point (window))))
 15984             {
 15985               w->suspend_auto_hscroll = false;
 15986               /* When hscrolling just the current line, and the rest
 15987                  of lines were temporarily hscrolled, but no longer
 15988                  are, force thorough redisplay of this window, to show
 15989                  the effect of disabling hscroll suspension immediately.  */
 15990               if (w->min_hscroll == 0 && w->hscroll > 0
 15991                   && EQ (Fbuffer_local_value (Qauto_hscroll_mode, w->contents),
 15992                          Qcurrent_line))
 15993                 SET_FRAME_GARBAGED (XFRAME (w->frame));
 15994             }
 15995 
 15996           /* Remember window point.  */
 15997           Fset_marker (w->old_pointm,
 15998                        ((w == XWINDOW (selected_window))
 15999                         ? make_fixnum (BUF_PT (XBUFFER (w->contents)))
 16000                         : Fmarker_position (w->pointm)),
 16001                        w->contents);
 16002 
 16003           if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode, w->contents))
 16004               && !w->suspend_auto_hscroll
 16005               /* In some pathological cases, like restoring a window
 16006                  configuration into a frame that is much smaller than
 16007                  the one from which the configuration was saved, we
 16008                  get glyph rows whose start and end have zero buffer
 16009                  positions, which we cannot handle below.  Just skip
 16010                  such windows.  */
 16011               && (CHARPOS (cursor_row->start.pos)
 16012                   >= BUF_BEG (XBUFFER (w->contents)))
 16013               /* For left-to-right rows, hscroll when cursor is either
 16014                  (i) inside the right hscroll margin, or (ii) if it is
 16015                  inside the left margin and the window is already
 16016                  hscrolled.  */
 16017               && ((!row_r2l_p
 16018                    && ((w->hscroll && w->cursor.x <= h_margin + x_offset)
 16019                        || (cursor_row->enabled_p
 16020                            && cursor_row->truncated_on_right_p
 16021                            && (w->cursor.x >= text_area_width - h_margin))))
 16022                   /* For right-to-left rows, the logic is similar,
 16023                      except that rules for scrolling to left and right
 16024                      are reversed.  E.g., if cursor.x <= h_margin, we
 16025                      need to hscroll "to the right" unconditionally,
 16026                      and that will scroll the screen to the left so as
 16027                      to reveal the next portion of the row.  */
 16028                   || (row_r2l_p
 16029                       && ((cursor_row->enabled_p
 16030                            /* FIXME: It is confusing to set the
 16031                               truncated_on_right_p flag when R2L rows
 16032                               are actually truncated on the left.  */
 16033                            && cursor_row->truncated_on_right_p
 16034                            && w->cursor.x <= h_margin)
 16035                           || (w->hscroll
 16036                               && (w->cursor.x >= (text_area_width - h_margin
 16037                                                   - x_offset)))))
 16038                   /* This last condition is needed when moving
 16039                      vertically from an hscrolled line to a short line
 16040                      that doesn't need to be hscrolled.  If we omit
 16041                      this condition, the line from which we move will
 16042                      remain hscrolled.  */
 16043                   || (hscl
 16044                       && w->hscroll != w->min_hscroll
 16045                       && !cursor_row->truncated_on_left_p)))
 16046             {
 16047               struct it it;
 16048               ptrdiff_t hscroll;
 16049               struct buffer *saved_current_buffer;
 16050               ptrdiff_t pt;
 16051               int wanted_x;
 16052 
 16053               /* Find point in a display of infinite width.  */
 16054               saved_current_buffer = current_buffer;
 16055               current_buffer = XBUFFER (w->contents);
 16056 
 16057               if (w == XWINDOW (selected_window))
 16058                 pt = PT;
 16059               else
 16060                 pt = clip_to_bounds (BEGV, marker_position (w->pointm), ZV);
 16061 
 16062               /* Move iterator to pt starting at cursor_row->start in
 16063                  a line with infinite width.  */
 16064               init_to_row_start (&it, w, cursor_row);
 16065               if (hscl)
 16066                 it.first_visible_x = window_hscroll_limited (w, it.f)
 16067                                      * FRAME_COLUMN_WIDTH (it.f);
 16068               it.last_visible_x = DISP_INFINITY;
 16069 
 16070               ptrdiff_t nchars = pt - IT_CHARPOS (it);
 16071               if (current_buffer->long_line_optimizations_p
 16072                   && nchars > large_hscroll_threshold)
 16073                 {
 16074                   /* Special optimization for very long and truncated
 16075                      lines which need to be hscrolled far to the left:
 16076                      jump directly to the (approximate) first position
 16077                      that is visible, instead of slowly walking there.  */
 16078                   fast_move_it_horizontally (&it, nchars);
 16079                   it.current_x += nchars * FRAME_COLUMN_WIDTH (it.f);
 16080                 }
 16081               else
 16082                 move_it_in_display_line_to (&it, pt, -1, MOVE_TO_POS);
 16083               /* If the line ends in an overlay string with a newline,
 16084                  we might infloop, because displaying the window will
 16085                  want to put the cursor after the overlay, i.e. at X
 16086                  coordinate of zero on the next screen line.  So we
 16087                  use the buffer position prior to the overlay string
 16088                  instead.  */
 16089               if (it.method == GET_FROM_STRING && pt > 1)
 16090                 {
 16091                   init_to_row_start (&it, w, cursor_row);
 16092                   if (hscl)
 16093                     it.first_visible_x = (window_hscroll_limited (w, it.f)
 16094                                           * FRAME_COLUMN_WIDTH (it.f));
 16095                   if (current_buffer->long_line_optimizations_p
 16096                       && nchars > large_hscroll_threshold)
 16097                     {
 16098                       fast_move_it_horizontally (&it, nchars - 1);
 16099                       it.current_x += (nchars - 1) * FRAME_COLUMN_WIDTH (it.f);
 16100                     }
 16101                   else
 16102                     move_it_in_display_line_to (&it, pt - 1, -1, MOVE_TO_POS);
 16103                 }
 16104               current_buffer = saved_current_buffer;
 16105 
 16106               /* Position cursor in window.  */
 16107               if (!hscroll_relative_p && hscroll_step_abs == 0)
 16108                 hscroll = max (0, (it.current_x
 16109                                    - (ITERATOR_AT_END_OF_LINE_P (&it)
 16110                                       ? (text_area_width - 4 * FRAME_COLUMN_WIDTH (it.f))
 16111                                       : (text_area_width / 2))))
 16112                           / FRAME_COLUMN_WIDTH (it.f);
 16113               else if ((!row_r2l_p
 16114                         && w->cursor.x >= text_area_width - h_margin)
 16115                        || (row_r2l_p && w->cursor.x <= h_margin))
 16116                 {
 16117                   if (hscroll_relative_p)
 16118                     wanted_x = text_area_width * (1 - hscroll_step_rel)
 16119                                - h_margin;
 16120                   else
 16121                     wanted_x = text_area_width
 16122                                - hscroll_step_abs * FRAME_COLUMN_WIDTH (it.f)
 16123                                - h_margin;
 16124                   hscroll
 16125                     = max (0, it.current_x - wanted_x) / FRAME_COLUMN_WIDTH (it.f);
 16126                 }
 16127               else
 16128                 {
 16129                   if (hscroll_relative_p)
 16130                     wanted_x =
 16131                       text_area_width * hscroll_step_rel + h_margin + x_offset;
 16132                   else
 16133                     wanted_x =
 16134                       hscroll_step_abs * FRAME_COLUMN_WIDTH (it.f)
 16135                       + h_margin + x_offset;
 16136                   hscroll
 16137                     = max (0, it.current_x - wanted_x) / FRAME_COLUMN_WIDTH (it.f);
 16138                 }
 16139               hscroll = max (hscroll, w->min_hscroll);
 16140 
 16141               /* Don't prevent redisplay optimizations if hscroll
 16142                  hasn't changed, as it will unnecessarily slow down
 16143                  redisplay.  */
 16144               if (w->hscroll != hscroll
 16145                   /* When hscrolling only the current line, we need to
 16146                      report hscroll even if its value is equal to the
 16147                      previous one, because the new line might need a
 16148                      different value.  */
 16149                   || (hscl && w->last_cursor_vpos != w->cursor.vpos))
 16150                 {
 16151                   struct buffer *b = XBUFFER (w->contents);
 16152                   b->prevent_redisplay_optimizations_p = true;
 16153                   w->hscroll = hscroll;
 16154                   hscrolled_p = true;
 16155                 }
 16156             }
 16157         }
 16158 
 16159       window = w->next;
 16160     }
 16161 
 16162   /* Value is true if hscroll of any leaf window has been changed.  */
 16163   return hscrolled_p;
 16164 }
 16165 
 16166 
 16167 /* Set hscroll so that cursor is visible and not inside horizontal
 16168    scroll margins for all windows in the tree rooted at WINDOW.  See
 16169    also hscroll_window_tree above.  Value is true if any window's
 16170    hscroll has been changed.  If it has, desired matrices on the frame
 16171    of WINDOW are cleared.  */
 16172 
 16173 static bool
 16174 hscroll_windows (Lisp_Object window)
 16175 {
 16176   bool hscrolled_p = hscroll_window_tree (window);
 16177   if (hscrolled_p)
 16178     clear_desired_matrices (XFRAME (WINDOW_FRAME (XWINDOW (window))));
 16179   return hscrolled_p;
 16180 }
 16181 
 16182 
 16183 
 16184 /************************************************************************
 16185                                 Redisplay
 16186  ************************************************************************/
 16187 
 16188 /* Variables holding some state of redisplay if GLYPH_DEBUG is defined.
 16189    This is sometimes handy to have in a debugger session.  */
 16190 
 16191 #ifdef GLYPH_DEBUG
 16192 
 16193 /* First and last unchanged row for try_window_id.  */
 16194 
 16195 static int debug_first_unchanged_at_end_vpos;
 16196 static int debug_last_unchanged_at_beg_vpos;
 16197 
 16198 /* Delta vpos and y.  */
 16199 
 16200 static int debug_dvpos, debug_dy;
 16201 
 16202 /* Delta in characters and bytes for try_window_id.  */
 16203 
 16204 static ptrdiff_t debug_delta, debug_delta_bytes;
 16205 
 16206 /* Values of window_end_pos and window_end_vpos at the end of
 16207    try_window_id.  */
 16208 
 16209 static ptrdiff_t debug_end_vpos;
 16210 
 16211 /* Append a string to W->desired_matrix->method.  FMT is a printf
 16212    format string.  If trace_redisplay_p is true also printf the
 16213    resulting string to stderr.  */
 16214 
 16215 static void debug_method_add (struct window *, char const *, ...)
 16216   ATTRIBUTE_FORMAT_PRINTF (2, 3);
 16217 
 16218 static void
 16219 debug_method_add (struct window *w, char const *fmt, ...)
 16220 {
 16221   void *ptr = w;
 16222   char *method = w->desired_matrix->method;
 16223   int len = strlen (method);
 16224   int size = sizeof w->desired_matrix->method;
 16225   int remaining = size - len - 1;
 16226   va_list ap;
 16227 
 16228   if (len && remaining)
 16229     {
 16230       method[len] = '|';
 16231       --remaining, ++len;
 16232     }
 16233 
 16234   va_start (ap, fmt);
 16235   vsnprintf (method + len, remaining + 1, fmt, ap);
 16236   va_end (ap);
 16237 
 16238   if (trace_redisplay_p)
 16239     fprintf (stderr, "%p (%s): %s\n",
 16240              ptr,
 16241              ((BUFFERP (w->contents)
 16242                && STRINGP (BVAR (XBUFFER (w->contents), name)))
 16243               ? SSDATA (BVAR (XBUFFER (w->contents), name))
 16244               : "no buffer"),
 16245              method + len);
 16246 }
 16247 
 16248 #endif /* GLYPH_DEBUG */
 16249 
 16250 
 16251 /* Value is true if all changes in window W, which displays
 16252    current_buffer, are in the text between START and END.  START is a
 16253    buffer position, END is given as a distance from Z.  Used in
 16254    redisplay_internal for display optimization.  */
 16255 
 16256 static bool
 16257 text_outside_line_unchanged_p (struct window *w,
 16258                                ptrdiff_t start, ptrdiff_t end)
 16259 {
 16260   bool unchanged_p = true;
 16261 
 16262   /* If text or overlays have changed, see where.  */
 16263   if (window_outdated (w))
 16264     {
 16265       /* Gap in the line?  */
 16266       if (GPT < start || Z - GPT < end)
 16267         unchanged_p = false;
 16268 
 16269       /* Changes start in front of the line, or end after it?  */
 16270       if (unchanged_p
 16271           && (BEG_UNCHANGED < start - 1
 16272               || END_UNCHANGED < end))
 16273         unchanged_p = false;
 16274 
 16275       /* If selective display, can't optimize if changes start at the
 16276          beginning of the line.  */
 16277       if (unchanged_p
 16278           && FIXNUMP (BVAR (current_buffer, selective_display))
 16279           && XFIXNUM (BVAR (current_buffer, selective_display)) > 0
 16280           && (BEG_UNCHANGED < start || GPT <= start))
 16281         unchanged_p = false;
 16282 
 16283       /* If there are overlays at the start or end of the line, these
 16284          may have overlay strings with newlines in them.  A change at
 16285          START, for instance, may actually concern the display of such
 16286          overlay strings as well, and they are displayed on different
 16287          lines.  So, quickly rule out this case.  (For the future, it
 16288          might be desirable to implement something more telling than
 16289          just BEG/END_UNCHANGED.)  */
 16290       if (unchanged_p)
 16291         {
 16292           if (BEG + BEG_UNCHANGED == start
 16293               && overlay_touches_p (start))
 16294             unchanged_p = false;
 16295           if (END_UNCHANGED == end
 16296               && overlay_touches_p (Z - end))
 16297             unchanged_p = false;
 16298         }
 16299 
 16300       /* Under bidi reordering, adding or deleting a character in the
 16301          beginning of a paragraph, before the first strong directional
 16302          character, can change the base direction of the paragraph (unless
 16303          the buffer specifies a fixed paragraph direction), which will
 16304          require redisplaying the whole paragraph.  It might be worthwhile
 16305          to find the paragraph limits and widen the range of redisplayed
 16306          lines to that, but for now just give up this optimization.  */
 16307       if (!NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering))
 16308           && NILP (BVAR (XBUFFER (w->contents), bidi_paragraph_direction)))
 16309         unchanged_p = false;
 16310     }
 16311 
 16312   return unchanged_p;
 16313 }
 16314 
 16315 
 16316 /* Do a frame update, taking possible shortcuts into account.  This is
 16317    the main external entry point for redisplay.
 16318 
 16319    If the last redisplay displayed an echo area message and that message
 16320    is no longer requested, we clear the echo area or bring back the
 16321    mini-buffer if that is in use.  */
 16322 
 16323 void
 16324 redisplay (void)
 16325 {
 16326   redisplay_internal ();
 16327 }
 16328 
 16329 
 16330 static Lisp_Object
 16331 overlay_arrow_string_or_property (Lisp_Object var)
 16332 {
 16333   Lisp_Object val;
 16334 
 16335   if (val = Fget (var, Qoverlay_arrow_string), STRINGP (val))
 16336     return val;
 16337 
 16338   return Voverlay_arrow_string;
 16339 }
 16340 
 16341 /* Return true if there are any overlay-arrows in current_buffer.  */
 16342 static bool
 16343 overlay_arrow_in_current_buffer_p (void)
 16344 {
 16345   Lisp_Object vlist;
 16346 
 16347   for (vlist = Voverlay_arrow_variable_list;
 16348        CONSP (vlist);
 16349        vlist = XCDR (vlist))
 16350     {
 16351       Lisp_Object var = XCAR (vlist);
 16352       Lisp_Object val;
 16353 
 16354       if (!SYMBOLP (var))
 16355         continue;
 16356       val = find_symbol_value (var);
 16357       if (MARKERP (val)
 16358           && current_buffer == XMARKER (val)->buffer)
 16359         return true;
 16360     }
 16361   return false;
 16362 }
 16363 
 16364 
 16365 /* Return true if any overlay_arrows have moved or overlay-arrow-string
 16366    has changed.
 16367    If SET_REDISPLAY is true, additionally, set the `redisplay' bit in those
 16368    buffers that are affected.  */
 16369 
 16370 static bool
 16371 overlay_arrows_changed_p (bool set_redisplay)
 16372 {
 16373   Lisp_Object vlist;
 16374   bool changed = false;
 16375 
 16376   for (vlist = Voverlay_arrow_variable_list;
 16377        CONSP (vlist);
 16378        vlist = XCDR (vlist))
 16379     {
 16380       Lisp_Object var = XCAR (vlist);
 16381       Lisp_Object val, pstr;
 16382 
 16383       if (!SYMBOLP (var))
 16384         continue;
 16385       val = find_symbol_value (var);
 16386       if (!MARKERP (val))
 16387         continue;
 16388       if (! EQ (Fmarker_position (val),
 16389                 /* FIXME: Don't we have a problem, using such a global
 16390                  * "last-position" if the variable is buffer-local?  */
 16391                 Fget (var, Qlast_arrow_position))
 16392           || ! (pstr = overlay_arrow_string_or_property (var),
 16393                 EQ (pstr, Fget (var, Qlast_arrow_string))))
 16394         {
 16395           struct buffer *buf = XMARKER (val)->buffer;
 16396 
 16397           if (set_redisplay)
 16398             {
 16399               if (buf)
 16400                 bset_redisplay (buf);
 16401               changed = true;
 16402             }
 16403           else
 16404             return true;
 16405         }
 16406     }
 16407   return changed;
 16408 }
 16409 
 16410 /* Mark overlay arrows to be updated on next redisplay.  */
 16411 
 16412 static void
 16413 update_overlay_arrows (int up_to_date)
 16414 {
 16415   Lisp_Object vlist;
 16416 
 16417   for (vlist = Voverlay_arrow_variable_list;
 16418        CONSP (vlist);
 16419        vlist = XCDR (vlist))
 16420     {
 16421       Lisp_Object var = XCAR (vlist);
 16422 
 16423       if (!SYMBOLP (var))
 16424         continue;
 16425 
 16426       if (up_to_date > 0)
 16427         {
 16428           Lisp_Object val = find_symbol_value (var);
 16429           if (!MARKERP (val))
 16430             continue;
 16431           Fput (var, Qlast_arrow_position, Fmarker_position (val));
 16432           Fput (var, Qlast_arrow_string,
 16433                 overlay_arrow_string_or_property (var));
 16434         }
 16435       else if (up_to_date < 0
 16436                || !NILP (Fget (var, Qlast_arrow_position)))
 16437         {
 16438           Fput (var, Qlast_arrow_position, Qt);
 16439           Fput (var, Qlast_arrow_string, Qt);
 16440         }
 16441     }
 16442 }
 16443 
 16444 
 16445 /* Return overlay arrow string to display at row.
 16446    Return integer (bitmap number) for arrow bitmap in left fringe.
 16447    Return nil if no overlay arrow.  */
 16448 
 16449 static Lisp_Object
 16450 overlay_arrow_at_row (struct it *it, struct glyph_row *row)
 16451 {
 16452   Lisp_Object vlist;
 16453 
 16454   for (vlist = Voverlay_arrow_variable_list;
 16455        CONSP (vlist);
 16456        vlist = XCDR (vlist))
 16457     {
 16458       Lisp_Object var = XCAR (vlist);
 16459       Lisp_Object val;
 16460 
 16461       if (!SYMBOLP (var))
 16462         continue;
 16463 
 16464       val = find_symbol_value (var);
 16465 
 16466       if (MARKERP (val)
 16467           && current_buffer == XMARKER (val)->buffer
 16468           && (MATRIX_ROW_START_CHARPOS (row) == marker_position (val)))
 16469         {
 16470           if (FRAME_WINDOW_P (it->f)
 16471               /* FIXME: if ROW->reversed_p is set, this should test
 16472                  the right fringe, not the left one.  */
 16473               && WINDOW_LEFT_FRINGE_WIDTH (it->w) > 0)
 16474             {
 16475 #ifdef HAVE_WINDOW_SYSTEM
 16476               if (val = Fget (var, Qoverlay_arrow_bitmap), SYMBOLP (val))
 16477                 {
 16478                   int fringe_bitmap = lookup_fringe_bitmap (val);
 16479                   if (fringe_bitmap != 0)
 16480                     return make_fixnum (fringe_bitmap);
 16481                 }
 16482 #endif
 16483               return make_fixnum (-1); /* Use default arrow bitmap.  */
 16484             }
 16485           return overlay_arrow_string_or_property (var);
 16486         }
 16487     }
 16488 
 16489   return Qnil;
 16490 }
 16491 
 16492 /* Return true if point moved out of or into a composition.  Otherwise
 16493    return false.  PREV_BUF and PREV_PT are the last point buffer and
 16494    position.  BUF and PT are the current point buffer and position.  */
 16495 
 16496 static bool
 16497 check_point_in_composition (struct buffer *prev_buf, ptrdiff_t prev_pt,
 16498                             struct buffer *buf, ptrdiff_t pt)
 16499 {
 16500   ptrdiff_t start, end;
 16501   Lisp_Object prop;
 16502   Lisp_Object buffer;
 16503 
 16504   XSETBUFFER (buffer, buf);
 16505   /* Check a composition at the last point if point moved within the
 16506      same buffer.  */
 16507   if (prev_buf == buf)
 16508     {
 16509       if (prev_pt == pt)
 16510         /* Point didn't move.  */
 16511         return false;
 16512 
 16513       if (prev_pt > BUF_BEGV (buf) && prev_pt < BUF_ZV (buf)
 16514           && find_composition (prev_pt, -1, &start, &end, &prop, buffer)
 16515           && composition_valid_p (start, end, prop)
 16516           && start < prev_pt && end > prev_pt)
 16517         /* The last point was within the composition.  Return true iff
 16518             point moved out of the composition.  */
 16519         return (pt <= start || pt >= end);
 16520     }
 16521 
 16522   /* Check a composition at the current point.  */
 16523   return (pt > BUF_BEGV (buf) && pt < BUF_ZV (buf)
 16524           && find_composition (pt, -1, &start, &end, &prop, buffer)
 16525           && composition_valid_p (start, end, prop)
 16526           && start < pt && end > pt);
 16527 }
 16528 
 16529 /* Reconsider the clip changes of buffer which is displayed in W.  */
 16530 
 16531 static void
 16532 reconsider_clip_changes (struct window *w)
 16533 {
 16534   struct buffer *b = XBUFFER (w->contents);
 16535 
 16536   if (b->clip_changed
 16537       && w->window_end_valid
 16538       && w->current_matrix->buffer == b
 16539       && w->current_matrix->zv == BUF_ZV (b)
 16540       && w->current_matrix->begv == BUF_BEGV (b))
 16541     b->clip_changed = false;
 16542 
 16543   /* If display wasn't paused, and W is not a tool bar window, see if
 16544      point has been moved into or out of a composition.  In that case,
 16545      set b->clip_changed to force updating the screen.  If
 16546      b->clip_changed has already been set, skip this check.  */
 16547   if (!b->clip_changed && w->window_end_valid)
 16548     {
 16549       ptrdiff_t pt = (w == XWINDOW (selected_window)
 16550                       ? PT : marker_position (w->pointm));
 16551 
 16552       if ((w->current_matrix->buffer != b || pt != w->last_point)
 16553           && check_point_in_composition (w->current_matrix->buffer,
 16554                                          w->last_point, b, pt))
 16555         b->clip_changed = true;
 16556     }
 16557 }
 16558 
 16559 static void
 16560 propagate_buffer_redisplay (void)
 16561 { /* Resetting b->text->redisplay is problematic!
 16562      We can't just reset it in the case that some window that displays
 16563      it has not been redisplayed; and such a window can stay
 16564      unredisplayed for a long time if it's currently invisible.
 16565      But we do want to reset it at the end of redisplay otherwise
 16566      its displayed windows will keep being redisplayed over and over
 16567      again.
 16568      So we copy all b->text->redisplay flags up to their windows here,
 16569      such that mark_window_display_accurate can safely reset
 16570      b->text->redisplay.  */
 16571   Lisp_Object ws = window_list ();
 16572   for (; CONSP (ws); ws = XCDR (ws))
 16573     {
 16574       struct window *thisw = XWINDOW (XCAR (ws));
 16575       struct buffer *thisb = XBUFFER (thisw->contents);
 16576       if (thisb->text->redisplay)
 16577         thisw->redisplay = true;
 16578     }
 16579 }
 16580 
 16581 #define STOP_POLLING                                    \
 16582 do { if (! polling_stopped_here) stop_polling ();       \
 16583        polling_stopped_here = true; } while (false)
 16584 
 16585 #define RESUME_POLLING                                  \
 16586 do { if (polling_stopped_here) start_polling ();        \
 16587        polling_stopped_here = false; } while (false)
 16588 
 16589 /* Perhaps in the future avoid recentering windows if it
 16590    is not necessary; currently that causes some problems.  */
 16591 
 16592 static void
 16593 redisplay_internal (void)
 16594 {
 16595   struct window *w = XWINDOW (selected_window);
 16596   struct window *sw;
 16597   struct frame *fr;
 16598   bool pending;
 16599   bool must_finish = false, match_p;
 16600   struct text_pos tlbufpos, tlendpos;
 16601   int number_of_visible_frames;
 16602   struct frame *sf;
 16603   bool polling_stopped_here = false;
 16604   Lisp_Object tail, frame;
 16605 
 16606   /* Set a limit to the number of retries we perform due to horizontal
 16607      scrolling, this avoids getting stuck in an uninterruptible
 16608      infinite loop (Bug #24633).  */
 16609   enum { MAX_HSCROLL_RETRIES = 16 };
 16610   int hscroll_retries = 0;
 16611 
 16612   /* Limit the number of retries for when frame(s) become garbaged as
 16613      result of redisplaying them.  Some packages set various redisplay
 16614      hooks, such as window-scroll-functions, to run Lisp that always
 16615      calls APIs which cause the frame's garbaged flag to become set,
 16616      so we loop indefinitely.  */
 16617   enum {MAX_GARBAGED_FRAME_RETRIES = 2 };
 16618   int garbaged_frame_retries = 0;
 16619 
 16620   /* False means that only the selected_window needs to be updated.
 16621      True means that other windows may need to be updated as well,
 16622      so we need to consult `needs_no_update` for all windows.  */
 16623   bool consider_all_windows_p;
 16624 
 16625   /* True means redisplay has to redisplay the miniwindow.  */
 16626   bool update_miniwindow_p = false;
 16627 
 16628   redisplay_trace ("redisplay_internal %d\n", redisplaying_p);
 16629 
 16630   /* No redisplay if running in batch mode or frame is not yet fully
 16631      initialized, or redisplay is explicitly turned off by setting
 16632      Vinhibit_redisplay.  */
 16633   if ((FRAME_INITIAL_P (SELECTED_FRAME ())
 16634        && redisplay_skip_initial_frame)
 16635       || !NILP (Vinhibit_redisplay))
 16636     return;
 16637 
 16638   /* Don't examine these until after testing Vinhibit_redisplay.
 16639      When Emacs is shutting down, perhaps because its connection to
 16640      X has dropped, we should not look at them at all.  */
 16641   fr = XFRAME (w->frame);
 16642   sf = SELECTED_FRAME ();
 16643 
 16644   if (!fr->glyphs_initialized_p)
 16645     return;
 16646 
 16647 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS)
 16648   if (popup_activated ())
 16649     return;
 16650 #endif
 16651 
 16652 #if defined (HAVE_HAIKU)
 16653   if (popup_activated_p)
 16654     return;
 16655 #endif
 16656 
 16657   /* I don't think this happens but let's be paranoid.  */
 16658   if (redisplaying_p)
 16659     return;
 16660 
 16661   /* Record a function that clears redisplaying_p
 16662      when we leave this function.  */
 16663   specpdl_ref count = SPECPDL_INDEX ();
 16664   record_unwind_protect_void (unwind_redisplay);
 16665   redisplaying_p = true;
 16666   block_buffer_flips ();
 16667   specbind (Qinhibit_free_realized_faces, Qnil);
 16668 
 16669   /* Record this function, so it appears on the profiler's backtraces.  */
 16670   record_in_backtrace (Qredisplay_internal_xC_functionx, 0, 0);
 16671 
 16672   FOR_EACH_FRAME (tail, frame)
 16673     XFRAME (frame)->already_hscrolled_p = false;
 16674 
 16675   reset_outermost_restrictions ();
 16676 
 16677  retry:
 16678   /* Remember the currently selected window.  */
 16679   sw = w;
 16680 
 16681   pending = false;
 16682   forget_escape_and_glyphless_faces ();
 16683 
 16684   inhibit_free_realized_faces = false;
 16685 
 16686   /* If face_change, init_iterator will free all realized faces, which
 16687      includes the faces referenced from current matrices.  So, we
 16688      can't reuse current matrices in this case.  */
 16689   if (face_change)
 16690     windows_or_buffers_changed = 47;
 16691 
 16692   if ((FRAME_TERMCAP_P (sf) || FRAME_MSDOS_P (sf))
 16693       && FRAME_TTY (sf)->previous_frame != sf)
 16694     {
 16695       /* Since frames on a single ASCII terminal share the same
 16696          display area, displaying a different frame means redisplay
 16697          the whole thing.  */
 16698       SET_FRAME_GARBAGED (sf);
 16699 #if !defined DOS_NT && !defined HAVE_ANDROID
 16700       set_tty_color_mode (FRAME_TTY (sf), sf);
 16701 #endif
 16702       FRAME_TTY (sf)->previous_frame = sf;
 16703     }
 16704 
 16705   /* Set the visible flags for all frames.  Do this before checking for
 16706      resized or garbaged frames; they want to know if their frames are
 16707      visible.  See the comment in frame.h for FRAME_SAMPLE_VISIBILITY.  */
 16708   number_of_visible_frames = 0;
 16709 
 16710   FOR_EACH_FRAME (tail, frame)
 16711     {
 16712       struct frame *f = XFRAME (frame);
 16713 
 16714       if (FRAME_REDISPLAY_P (f))
 16715         {
 16716           ++number_of_visible_frames;
 16717           /* Adjust matrices for visible frames only.  */
 16718           if (f->fonts_changed)
 16719             {
 16720               adjust_frame_glyphs (f);
 16721               /* Disable all redisplay optimizations for this frame.
 16722                  This is because adjust_frame_glyphs resets the
 16723                  enabled_p flag for all glyph rows of all windows, so
 16724                  many optimizations will fail anyway, and some might
 16725                  fail to test that flag and do bogus things as
 16726                  result.  */
 16727               SET_FRAME_GARBAGED (f);
 16728               f->fonts_changed = false;
 16729             }
 16730           /* If cursor type has been changed on the frame
 16731              other than selected, consider all frames.  */
 16732           if (f != sf && f->cursor_type_changed)
 16733             fset_redisplay (f);
 16734         }
 16735       clear_desired_matrices (f);
 16736     }
 16737 
 16738   /* Notice any pending interrupt request to change frame size.  */
 16739   do_pending_window_change (true);
 16740 
 16741   /* Clear frames marked as garbaged.  */
 16742   clear_garbaged_frames ();
 16743 
 16744   /* Build menubar and tool-bar items.  */
 16745   if (NILP (Vmemory_full))
 16746     prepare_menu_bars ();
 16747 
 16748   /* do_pending_window_change could change the selected_window due to
 16749      frame resizing which makes the selected window too small.
 16750      prepare_menu_bars may call lisp hooks and hence also change the
 16751      selected_window.  */
 16752   if (WINDOWP (selected_window) && (w = XWINDOW (selected_window)) != sw)
 16753     sw = w;
 16754 
 16755   reconsider_clip_changes (w);
 16756 
 16757   /* In most cases selected window displays current buffer.  */
 16758   match_p = XBUFFER (w->contents) == current_buffer;
 16759   if (match_p)
 16760     {
 16761       /* Detect case that we need to write or remove a star in the mode line.  */
 16762       if ((SAVE_MODIFF < MODIFF) != w->last_had_star)
 16763         w->update_mode_line = true;
 16764 
 16765       if (mode_line_update_needed (w))
 16766         w->update_mode_line = true;
 16767 
 16768       /* If reconsider_clip_changes above decided that the narrowing
 16769          in the current buffer changed, make sure all other windows
 16770          showing that buffer will be redisplayed.  */
 16771       if (current_buffer->clip_changed)
 16772         bset_update_mode_line (current_buffer);
 16773     }
 16774 
 16775   /* Normally the message* functions will have already displayed and
 16776      updated the echo area, but the frame may have been trashed, or
 16777      the update may have been preempted, so display the echo area
 16778      again here.  Checking message_cleared_p captures the case that
 16779      the echo area should be cleared.  */
 16780   if ((!NILP (echo_area_buffer[0]) && !display_last_displayed_message_p)
 16781       || (!NILP (echo_area_buffer[1]) && display_last_displayed_message_p)
 16782       || (message_cleared_p
 16783           && minibuf_level == 0
 16784           /* If the mini-window is currently selected, this means the
 16785              echo-area doesn't show through.  */
 16786           && !MINI_WINDOW_P (XWINDOW (selected_window))))
 16787     {
 16788       echo_area_display (false);
 16789 
 16790       if (message_cleared_p)
 16791         update_miniwindow_p = true;
 16792 
 16793       must_finish = true;
 16794 
 16795       /* If we don't display the current message, don't clear the
 16796          message_cleared_p flag, because, if we did, we wouldn't clear
 16797          the echo area in the next redisplay which doesn't preserve
 16798          the echo area.  */
 16799       if (!display_last_displayed_message_p)
 16800         message_cleared_p = false;
 16801     }
 16802   else if (EQ (selected_window, minibuf_window)
 16803            && (current_buffer->clip_changed || window_outdated (w))
 16804            && resize_mini_window (w, false))
 16805     {
 16806       /* Resized active mini-window to fit the size of what it is
 16807          showing if its contents might have changed.  */
 16808       must_finish = true;
 16809 
 16810       /* If window configuration was changed, frames may have been
 16811          marked garbaged.  Clear them or we will experience
 16812          surprises wrt scrolling.  */
 16813       clear_garbaged_frames ();
 16814     }
 16815 
 16816   if (!NILP (Vrun_hooks))
 16817     run_window_change_functions ();
 16818 
 16819   if (windows_or_buffers_changed && !update_mode_lines)
 16820     /* Code that sets windows_or_buffers_changed doesn't distinguish whether
 16821        only the windows's contents needs to be refreshed, or whether the
 16822        mode-lines also need a refresh.  */
 16823     update_mode_lines = (windows_or_buffers_changed == REDISPLAY_SOME
 16824                          ? REDISPLAY_SOME : 32);
 16825 
 16826   /* If specs for an arrow have changed, do thorough redisplay
 16827      to ensure we remove any arrow that should no longer exist.  */
 16828   /* Apparently, this is the only case where we update other windows,
 16829      without updating other mode-lines.  */
 16830   overlay_arrows_changed_p (true);
 16831 
 16832   consider_all_windows_p = (update_mode_lines
 16833                             || windows_or_buffers_changed);
 16834 
 16835 #define AINC(a,i)                                                       \
 16836   {                                                                     \
 16837     Lisp_Object entry = Fgethash (make_fixnum (i), a, make_fixnum (0)); \
 16838     if (FIXNUMP (entry))                                                \
 16839       Fputhash (make_fixnum (i), make_fixnum (1 + XFIXNUM (entry)), a); \
 16840   }
 16841 
 16842   AINC (Vredisplay__all_windows_cause, windows_or_buffers_changed);
 16843   AINC (Vredisplay__mode_lines_cause, update_mode_lines);
 16844 
 16845   /* Optimize the case that only the line containing the cursor in the
 16846      selected window has changed.  Variables starting with this_ are
 16847      set in display_line and record information about the line
 16848      containing the cursor.  */
 16849   tlbufpos = this_line_start_pos;
 16850   tlendpos = this_line_end_pos;
 16851   if (!consider_all_windows_p
 16852       && CHARPOS (tlbufpos) > 0
 16853       && !w->update_mode_line
 16854       && !current_buffer->clip_changed
 16855       && !current_buffer->prevent_redisplay_optimizations_p
 16856       && FRAME_REDISPLAY_P (XFRAME (w->frame))
 16857       && !FRAME_OBSCURED_P (XFRAME (w->frame))
 16858       && !XFRAME (w->frame)->cursor_type_changed
 16859       && !XFRAME (w->frame)->face_change
 16860       /* Make sure recorded data applies to current buffer, etc.  */
 16861       && this_line_buffer == current_buffer
 16862       && match_p
 16863       && !w->force_start
 16864       && !w->optional_new_start
 16865       /* Point must be on the line that we have info recorded about.  */
 16866       && PT >= CHARPOS (tlbufpos)
 16867       && PT <= Z - CHARPOS (tlendpos)
 16868       /* FIXME: The following condition is only needed when
 16869          significant parts of the buffer are hidden (e.g., under
 16870          hs-minor-mode), but there doesn't seem to be a simple way of
 16871          detecting that, so we always disable the one-line redisplay
 16872          optimizations whenever display-line-numbers-mode is turned on
 16873          in the buffer.  */
 16874       && (NILP (Vdisplay_line_numbers)
 16875           || EQ (Vdisplay_line_numbers, Qvisual))
 16876       /* All text outside that line, including its final newline,
 16877          must be unchanged.  */
 16878       && text_outside_line_unchanged_p (w, CHARPOS (tlbufpos),
 16879                                         CHARPOS (tlendpos)))
 16880     {
 16881       if (CHARPOS (tlbufpos) > BEGV
 16882           && FETCH_BYTE (BYTEPOS (tlbufpos) - 1) != '\n'
 16883           && (CHARPOS (tlbufpos) == ZV
 16884               || FETCH_BYTE (BYTEPOS (tlbufpos)) == '\n'))
 16885         /* Former continuation line has disappeared by becoming empty.  */
 16886         goto cancel;
 16887       else if (window_outdated (w) || MINI_WINDOW_P (w))
 16888         {
 16889           /* We have to handle the case of continuation around a
 16890              wide-column character (see the comment in indent.c around
 16891              line 1340).
 16892 
 16893              For instance, in the following case:
 16894 
 16895              --------  Insert  --------
 16896              K_A_N_\\   `a'    K_A_N_a\         `X_' are wide-column chars.
 16897              J_I_       ==>    J_I_             `^^' are cursors.
 16898              ^^                ^^
 16899              --------          --------
 16900 
 16901              As we have to redraw the line above, we cannot use this
 16902              optimization.  */
 16903 
 16904           struct it it;
 16905           int line_height_before = this_line_pixel_height;
 16906 
 16907           /* Note that start_display will handle the case that the
 16908              line starting at tlbufpos is a continuation line.  */
 16909           start_display (&it, w, tlbufpos);
 16910 
 16911           /* Implementation note: It this still necessary?  */
 16912           if (it.current_x != this_line_start_x)
 16913             goto cancel;
 16914 
 16915           /* Give up on this optimization if the line starts with a
 16916              string with display property that draws on the fringes,
 16917              as that might interfere with line-prefix display.  */
 16918           if (it.sp > 1
 16919               && it.method == GET_FROM_IMAGE && it.image_id == -1)
 16920             goto cancel;
 16921           redisplay_trace ("trying display optimization 1\n");
 16922           w->cursor.vpos = -1;
 16923           overlay_arrow_seen = false;
 16924           it.vpos = this_line_vpos;
 16925           it.current_y = this_line_y;
 16926           it.glyph_row = MATRIX_ROW (w->desired_matrix, this_line_vpos);
 16927           display_line (&it, -1);
 16928 
 16929           /* If line contains point, is not continued,
 16930              and ends at same distance from eob as before, we win.  */
 16931           if (w->cursor.vpos >= 0
 16932               /* Line is not continued, otherwise this_line_start_pos
 16933                  would have been set to 0 in display_line.  */
 16934               && CHARPOS (this_line_start_pos)
 16935               /* Line ends as before.  */
 16936               && CHARPOS (this_line_end_pos) == CHARPOS (tlendpos)
 16937               /* Line has same height as before.  Otherwise other lines
 16938                  would have to be shifted up or down.  */
 16939               && this_line_pixel_height == line_height_before
 16940               /* Cannot use this optimization if hscrolling current
 16941                  line and this line is the current one, because
 16942                  display_line above is not informed about the
 16943                  current-line's vpos, and cannot DTRT in that case.  */
 16944               && !hscrolling_current_line_p (w))
 16945             {
 16946               /* If this is not the window's last line, we must adjust
 16947                  the charstarts of the lines below.  */
 16948               if (it.current_y < it.last_visible_y)
 16949                 {
 16950                   struct glyph_row *row
 16951                     = MATRIX_ROW (w->current_matrix, this_line_vpos + 1);
 16952                   ptrdiff_t delta, delta_bytes;
 16953 
 16954                   /* We used to distinguish between two cases here,
 16955                      conditioned by Z - CHARPOS (tlendpos) == ZV, for
 16956                      when the line ends in a newline or the end of the
 16957                      buffer's accessible portion.  But both cases did
 16958                      the same, so they were collapsed.  */
 16959                   delta = (Z
 16960                            - CHARPOS (tlendpos)
 16961                            - MATRIX_ROW_START_CHARPOS (row));
 16962                   delta_bytes = (Z_BYTE
 16963                                  - BYTEPOS (tlendpos)
 16964                                  - MATRIX_ROW_START_BYTEPOS (row));
 16965 
 16966                   increment_matrix_positions (w->current_matrix,
 16967                                               this_line_vpos + 1,
 16968                                               w->current_matrix->nrows,
 16969                                               delta, delta_bytes);
 16970                 }
 16971 
 16972               /* If this row displays text now but previously didn't,
 16973                  or vice versa, w->window_end_vpos may have to be
 16974                  adjusted.  */
 16975               if (MATRIX_ROW_DISPLAYS_TEXT_P (it.glyph_row - 1))
 16976                 {
 16977                   if (w->window_end_vpos < this_line_vpos)
 16978                     w->window_end_vpos = this_line_vpos;
 16979                 }
 16980               else if (w->window_end_vpos == this_line_vpos
 16981                        && this_line_vpos > 0)
 16982                 w->window_end_vpos = this_line_vpos - 1;
 16983               w->window_end_valid = false;
 16984 
 16985               /* Update hint: No need to try to scroll in update_window.  */
 16986               w->desired_matrix->no_scrolling_p = true;
 16987 
 16988 #ifdef GLYPH_DEBUG
 16989               *w->desired_matrix->method = 0;
 16990               debug_method_add (w, "optimization 1");
 16991 #endif
 16992 #ifdef HAVE_WINDOW_SYSTEM
 16993               update_window_fringes (w, false);
 16994 #endif
 16995               goto update;
 16996             }
 16997           else
 16998             goto cancel;
 16999         }
 17000       else if (/* Cursor position hasn't changed.  */
 17001                PT == w->last_point
 17002                /* Make sure the cursor was last displayed
 17003                   in this window.  Otherwise we have to reposition it.  */
 17004 
 17005                /* PXW: Must be converted to pixels, probably.  */
 17006                && 0 <= w->cursor.vpos
 17007                && w->cursor.vpos < WINDOW_TOTAL_LINES (w))
 17008         {
 17009           if (!must_finish)
 17010             {
 17011               do_pending_window_change (true);
 17012               /* If selected_window changed, redisplay again.  */
 17013               if (WINDOWP (selected_window)
 17014                   && (w = XWINDOW (selected_window)) != sw)
 17015                 goto retry;
 17016 
 17017                 /* We used to always goto end_of_redisplay here, but this
 17018                  isn't enough if we have a blinking cursor.  */
 17019               if (w->cursor_off_p == w->last_cursor_off_p)
 17020                 goto end_of_redisplay;
 17021             }
 17022           goto update;
 17023         }
 17024       /* If highlighting the region, or if the cursor is in the echo area,
 17025          then we can't just move the cursor.  */
 17026       else if (NILP (Vshow_trailing_whitespace)
 17027                && !cursor_in_echo_area
 17028                && !composition_break_at_point)
 17029         {
 17030           struct it it;
 17031           struct glyph_row *row;
 17032 
 17033           /* Skip from tlbufpos to PT and see where it is.  Note that
 17034              PT may be in invisible text.  If so, we will end at the
 17035              next visible position.  */
 17036           init_iterator (&it, w, CHARPOS (tlbufpos), BYTEPOS (tlbufpos),
 17037                          NULL, DEFAULT_FACE_ID);
 17038           it.current_x = this_line_start_x;
 17039           it.current_y = this_line_y;
 17040           it.vpos = this_line_vpos;
 17041 
 17042           if (current_buffer->long_line_optimizations_p
 17043               && it.line_wrap == TRUNCATE
 17044               && PT - CHARPOS (tlbufpos) > large_hscroll_threshold)
 17045             {
 17046               /* When lines are very long and truncated, jumping to
 17047                  the next visible line is much faster than slowly
 17048                  iterating there.  */
 17049               reseat_at_next_visible_line_start (&it, false);
 17050               if (IT_CHARPOS (it) <= PT) /* point moved off this line */
 17051                 it.vpos = this_line_vpos + 1;
 17052             }
 17053           else
 17054             {
 17055               /* The call to move_it_to stops in front of PT, but
 17056                  moves over before-strings.  */
 17057               move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
 17058             }
 17059 
 17060           if (it.vpos == this_line_vpos
 17061               && (row = MATRIX_ROW (w->current_matrix, this_line_vpos),
 17062                   row->enabled_p))
 17063             {
 17064               eassert (this_line_vpos == it.vpos);
 17065               eassert (this_line_y == it.current_y);
 17066               set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
 17067               if (cursor_row_fully_visible_p (w, false, true, false))
 17068                 {
 17069 #ifdef GLYPH_DEBUG
 17070                   *w->desired_matrix->method = 0;
 17071                   debug_method_add (w, "optimization 3");
 17072 #endif
 17073                   goto update;
 17074                 }
 17075               else
 17076                 goto cancel;
 17077             }
 17078           else
 17079             goto cancel;
 17080         }
 17081 
 17082     cancel:
 17083       /* Text changed drastically or point moved off of line.  */
 17084       SET_MATRIX_ROW_ENABLED_P (w->desired_matrix, this_line_vpos, false);
 17085     }
 17086 
 17087   CHARPOS (this_line_start_pos) = 0;
 17088   ++clear_face_cache_count;
 17089 #ifdef HAVE_WINDOW_SYSTEM
 17090   ++clear_image_cache_count;
 17091 #endif
 17092 
 17093   /* Build desired matrices, and update the display.  If
 17094      consider_all_windows_p, do it for all windows on all frames that
 17095      require redisplay, as specified by their 'redisplay' flag.
 17096      Otherwise do it for selected_window, only.  */
 17097 
 17098   if (consider_all_windows_p)
 17099     {
 17100       FOR_EACH_FRAME (tail, frame)
 17101         XFRAME (frame)->updated_p = false;
 17102 
 17103       propagate_buffer_redisplay ();
 17104 
 17105       FOR_EACH_FRAME (tail, frame)
 17106         {
 17107           struct frame *f = XFRAME (frame);
 17108 
 17109           /* We don't have to do anything for unselected terminal
 17110              frames.  */
 17111           if ((FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))
 17112               && !EQ (FRAME_TTY (f)->top_frame, frame))
 17113             continue;
 17114 
 17115         retry_frame:
 17116           if (FRAME_WINDOW_P (f) || FRAME_TERMCAP_P (f) || f == sf)
 17117             {
 17118               bool gcscrollbars
 17119                 /* Only GC scrollbars when we redisplay the whole frame.  */
 17120                 = f->redisplay || !REDISPLAY_SOME_P ();
 17121               bool f_redisplay_flag = f->redisplay;
 17122 
 17123               /* The X error handler may have deleted that frame
 17124                  before we went back to retry_frame.  This must come
 17125                  before any accesses to f->terminal.  */
 17126               if (!FRAME_LIVE_P (f))
 17127                 continue;
 17128 
 17129               /* Mark all the scroll bars to be removed; we'll redeem
 17130                  the ones we want when we redisplay their windows.  */
 17131               if (gcscrollbars && FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
 17132                 FRAME_TERMINAL (f)->condemn_scroll_bars_hook (f);
 17133 
 17134               if (FRAME_REDISPLAY_P (f) && !FRAME_OBSCURED_P (f))
 17135                 {
 17136                   /* Don't allow freeing images and faces for this
 17137                      frame as long as the frame's update wasn't
 17138                      completed.  This prevents crashes when some Lisp
 17139                      that runs from the various hooks or font-lock
 17140                      decides to clear the frame's image cache and face
 17141                      cache, when the images and faces in those caches
 17142                      are referenced by the desired matrix.  */
 17143                   f->inhibit_clear_image_cache = true;
 17144                   redisplay_windows (FRAME_ROOT_WINDOW (f));
 17145                 }
 17146               /* Remember that the invisible frames need to be redisplayed next
 17147                  time they're visible.  */
 17148               else if (!REDISPLAY_SOME_P ())
 17149                 f->redisplay = true;
 17150 
 17151               /* The X error handler may have deleted that frame.  */
 17152               if (!FRAME_LIVE_P (f))
 17153                 continue;
 17154 
 17155               /* Any scroll bars which redisplay_windows should have
 17156                  nuked should now go away.  */
 17157               if (gcscrollbars && FRAME_TERMINAL (f)->judge_scroll_bars_hook)
 17158                 FRAME_TERMINAL (f)->judge_scroll_bars_hook (f);
 17159 
 17160               if (FRAME_REDISPLAY_P (f) && !FRAME_OBSCURED_P (f))
 17161                 {
 17162                   /* If fonts changed on visible frame, display again.  */
 17163                   if (f->fonts_changed)
 17164                     {
 17165                       adjust_frame_glyphs (f);
 17166                       /* Disable all redisplay optimizations for this
 17167                          frame.  For the reasons, see the comment near
 17168                          the previous call to adjust_frame_glyphs above.  */
 17169                       SET_FRAME_GARBAGED (f);
 17170                       f->fonts_changed = false;
 17171                       goto retry_frame;
 17172                     }
 17173 
 17174                   /* See if we have to hscroll.  */
 17175                   if (!f->already_hscrolled_p)
 17176                     {
 17177                       f->already_hscrolled_p = true;
 17178                       if (hscroll_retries <= MAX_HSCROLL_RETRIES
 17179                           && hscroll_windows (f->root_window))
 17180                         {
 17181                           hscroll_retries++;
 17182                           goto retry_frame;
 17183                         }
 17184                     }
 17185 
 17186                   /* If the frame's redisplay flag was not set before
 17187                      we went about redisplaying its windows, but it is
 17188                      set now, that means we employed some redisplay
 17189                      optimizations inside redisplay_windows, and
 17190                      bypassed producing some screen lines.  But if
 17191                      f->redisplay is now set, it might mean the old
 17192                      faces are no longer valid (e.g., if redisplaying
 17193                      some window called some Lisp which defined a new
 17194                      face or redefined an existing face), so trying to
 17195                      use them in update_frame will segfault.
 17196                      Therefore, we must redisplay this frame.  */
 17197                   if (!f_redisplay_flag && f->redisplay)
 17198                     goto retry_frame;
 17199                   /* In some case (e.g., window resize), we notice
 17200                      only during window updating that the window
 17201                      content changed unpredictably (e.g., a GTK
 17202                      scrollbar moved, or some Lisp hook that winds up
 17203                      calling adjust_frame_glyphs) and that our
 17204                      previous estimation of the frame content was
 17205                      garbage.  We have to start over.  These cases
 17206                      should be rare, so going all the way back to the
 17207                      top of redisplay should be good enough.  */
 17208                   if (FRAME_GARBAGED_P (f)
 17209                       && garbaged_frame_retries++ < MAX_GARBAGED_FRAME_RETRIES)
 17210                     goto retry;
 17211 
 17212 #ifdef HAVE_WINDOW_SYSTEM
 17213                   if (FRAME_WINDOW_P (f)
 17214                       && FRAME_RIF (f)->clear_under_internal_border)
 17215                     FRAME_RIF (f)->clear_under_internal_border (f);
 17216 #endif
 17217                   /* Prevent various kinds of signals during display
 17218                      update.  stdio is not robust about handling
 17219                      signals, which can cause an apparent I/O error.  */
 17220                   if (interrupt_input)
 17221                     unrequest_sigio ();
 17222                   STOP_POLLING;
 17223 
 17224                   pending |= update_frame (f, false, false);
 17225                   /* On some platforms (at least MS-Windows), the
 17226                      scroll_run_hook called from scrolling_window
 17227                      called from update_frame could set the frame's
 17228                      garbaged flag, in which case we need to redisplay
 17229                      the frame.  Don't do that on TTY frames, since we
 17230                      need to keep the garbaged flag in that case when
 17231                      the frame has been resized.  */
 17232                   if (FRAME_GARBAGED_P (f))
 17233                     {
 17234                       fset_redisplay (f);
 17235                       f->garbaged = false;
 17236                       goto retry_frame;
 17237                     }
 17238                   f->cursor_type_changed = false;
 17239                   f->updated_p = true;
 17240                   f->inhibit_clear_image_cache = false;
 17241                 }
 17242             }
 17243         }
 17244 
 17245       eassert (EQ (XFRAME (selected_frame)->selected_window, selected_window));
 17246 
 17247       if (!pending)
 17248         {
 17249           /* Do the mark_window_display_accurate after all windows have
 17250              been redisplayed because this call resets flags in buffers
 17251              which are needed for proper redisplay.  */
 17252           FOR_EACH_FRAME (tail, frame)
 17253             {
 17254               struct frame *f = XFRAME (frame);
 17255               if (f->updated_p)
 17256                 {
 17257                   f->redisplay = false;
 17258                   f->garbaged = false;
 17259                   mark_window_display_accurate (f->root_window, true);
 17260                   if (FRAME_TERMINAL (f)->frame_up_to_date_hook)
 17261                     FRAME_TERMINAL (f)->frame_up_to_date_hook (f);
 17262                 }
 17263             }
 17264         }
 17265     }
 17266   else if (FRAME_REDISPLAY_P (sf) && !FRAME_OBSCURED_P (sf))
 17267     {
 17268       sf->inhibit_clear_image_cache = true;
 17269       displayed_buffer = XBUFFER (XWINDOW (selected_window)->contents);
 17270       /* Use list_of_error, not Qerror, so that
 17271          we catch only errors and don't run the debugger.  */
 17272       internal_condition_case_1 (redisplay_window_1, selected_window,
 17273                                  list_of_error,
 17274                                  redisplay_window_error);
 17275       if (update_miniwindow_p)
 17276         {
 17277           Lisp_Object mini_window = FRAME_MINIBUF_WINDOW (sf);
 17278 
 17279           displayed_buffer = XBUFFER (XWINDOW (mini_window)->contents);
 17280           internal_condition_case_1 (redisplay_window_1, mini_window,
 17281                                      list_of_error,
 17282                                      redisplay_window_error);
 17283         }
 17284 
 17285       /* Compare desired and current matrices, perform output.  */
 17286 
 17287     update:
 17288       /* If fonts changed, display again.  Likewise if redisplay_window_1
 17289          above caused some change (e.g., a change in faces) that requires
 17290          considering the entire frame again.  */
 17291       if (sf->fonts_changed || sf->redisplay)
 17292         {
 17293           if (sf->redisplay)
 17294             {
 17295               /* Set this to force a more thorough redisplay.
 17296                  Otherwise, we might immediately loop back to the
 17297                  above "else-if" clause (since all the conditions that
 17298                  led here might still be true), and we will then
 17299                  infloop, because the selected-frame's redisplay flag
 17300                  is not (and cannot be) reset.  */
 17301               windows_or_buffers_changed = 50;
 17302             }
 17303           goto retry;
 17304         }
 17305 
 17306       /* Prevent freeing of realized faces, since desired matrices are
 17307          pending that reference the faces we computed and cached.  */
 17308       inhibit_free_realized_faces = true;
 17309 
 17310       /* Prevent various kinds of signals during display update.
 17311          stdio is not robust about handling signals,
 17312          which can cause an apparent I/O error.  */
 17313       if (interrupt_input)
 17314         unrequest_sigio ();
 17315       STOP_POLLING;
 17316 
 17317       if (FRAME_REDISPLAY_P (sf) && !FRAME_OBSCURED_P (sf))
 17318         {
 17319           if (hscroll_retries <= MAX_HSCROLL_RETRIES
 17320               && hscroll_windows (selected_window))
 17321             {
 17322               hscroll_retries++;
 17323               goto retry;
 17324             }
 17325 
 17326           XWINDOW (selected_window)->must_be_updated_p = true;
 17327           pending = update_frame (sf, false, false);
 17328           sf->cursor_type_changed = false;
 17329           sf->inhibit_clear_image_cache = false;
 17330         }
 17331 
 17332       /* We may have called echo_area_display at the top of this
 17333          function.  If the echo area is on another frame, that may
 17334          have put text on a frame other than the selected one, so the
 17335          above call to update_frame would not have caught it.  Catch
 17336          it here.  */
 17337       Lisp_Object mini_window = FRAME_MINIBUF_WINDOW (sf);
 17338       struct frame *mini_frame = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
 17339 
 17340       if (mini_frame != sf && FRAME_WINDOW_P (mini_frame))
 17341         {
 17342           XWINDOW (mini_window)->must_be_updated_p = true;
 17343           pending |= update_frame (mini_frame, false, false);
 17344           mini_frame->cursor_type_changed = false;
 17345           if (!pending && hscroll_retries <= MAX_HSCROLL_RETRIES
 17346               && hscroll_windows (mini_window))
 17347             {
 17348               hscroll_retries++;
 17349               goto retry;
 17350             }
 17351         }
 17352     }
 17353 
 17354   /* If display was paused because of pending input, make sure we do a
 17355      thorough update the next time.  */
 17356   if (pending)
 17357     {
 17358       /* Prevent the optimization at the beginning of
 17359          redisplay_internal that tries a single-line update of the
 17360          line containing the cursor in the selected window.  */
 17361       CHARPOS (this_line_start_pos) = 0;
 17362 
 17363       /* Let the overlay arrow be updated the next time.  */
 17364       update_overlay_arrows (0);
 17365 
 17366       /* If we pause after scrolling, some rows in the current
 17367          matrices of some windows are not valid.  */
 17368       if (!WINDOW_FULL_WIDTH_P (w)
 17369           && !FRAME_WINDOW_P (XFRAME (w->frame)))
 17370         update_mode_lines = 36;
 17371     }
 17372   else
 17373     {
 17374       if (!consider_all_windows_p)
 17375         {
 17376           /* This has already been done above if
 17377              consider_all_windows_p is set.  */
 17378           if (XBUFFER (w->contents)->text->redisplay
 17379               && buffer_window_count (XBUFFER (w->contents)) > 1)
 17380             /* This can happen if b->text->redisplay was set during
 17381                jit-lock.  */
 17382             propagate_buffer_redisplay ();
 17383           mark_window_display_accurate_1 (w, true);
 17384 
 17385           /* Say overlay arrows are up to date.  */
 17386           update_overlay_arrows (1);
 17387 
 17388           if (FRAME_TERMINAL (sf)->frame_up_to_date_hook != 0)
 17389             FRAME_TERMINAL (sf)->frame_up_to_date_hook (sf);
 17390         }
 17391 
 17392       update_mode_lines = 0;
 17393       windows_or_buffers_changed = 0;
 17394     }
 17395 
 17396   /* Start SIGIO interrupts coming again.  Having them off during the
 17397      code above makes it less likely one will discard output, but not
 17398      impossible, since there might be stuff in the system buffer here.
 17399      But it is much hairier to try to do anything about that.  */
 17400   if (interrupt_input)
 17401     request_sigio ();
 17402   RESUME_POLLING;
 17403 
 17404   /* If a frame has become visible which was not before, redisplay
 17405      again, so that we display it.  Expose events for such a frame
 17406      (which it gets when becoming visible) don't call the parts of
 17407      redisplay constructing glyphs, so simply exposing a frame won't
 17408      display anything in this case.  So, we have to display these
 17409      frames here explicitly.  */
 17410   if (!pending)
 17411     {
 17412       int new_count = 0;
 17413 
 17414       FOR_EACH_FRAME (tail, frame)
 17415         {
 17416           if (FRAME_REDISPLAY_P (XFRAME (frame)))
 17417             new_count++;
 17418         }
 17419 
 17420       if (new_count != number_of_visible_frames)
 17421         windows_or_buffers_changed = 52;
 17422     }
 17423 
 17424   /* Change frame size now if a change is pending.  */
 17425   do_pending_window_change (true);
 17426 
 17427   /* If we just did a pending size change, or have additional
 17428      visible frames, or selected_window changed, redisplay again.  */
 17429   if ((windows_or_buffers_changed && !pending)
 17430       || (WINDOWP (selected_window)
 17431           && (w = XWINDOW (selected_window)) != sw))
 17432     goto retry;
 17433 
 17434   /* Clear the face and image caches.
 17435 
 17436      We used to do this only if consider_all_windows_p.  But the cache
 17437      needs to be cleared if a timer creates images in the current
 17438      buffer (e.g. the test case in Bug#6230).  */
 17439 
 17440   if (clear_face_cache_count > CLEAR_FACE_CACHE_COUNT)
 17441     {
 17442       clear_face_cache (false);
 17443       clear_face_cache_count = 0;
 17444     }
 17445 
 17446 #ifdef HAVE_WINDOW_SYSTEM
 17447   if (clear_image_cache_count > CLEAR_IMAGE_CACHE_COUNT)
 17448     {
 17449       clear_image_caches (Qnil);
 17450       clear_image_cache_count = 0;
 17451     }
 17452 #endif /* HAVE_WINDOW_SYSTEM */
 17453 
 17454  end_of_redisplay:
 17455 #ifdef HAVE_NS
 17456   ns_set_doc_edited ();
 17457 #endif
 17458   if (interrupt_input && interrupts_deferred)
 17459     request_sigio ();
 17460 
 17461   /* We're done with this redisplay cycle, so reset the tick count in
 17462      preparation for the next redisplay cycle.  */
 17463   if (max_redisplay_ticks > 0)
 17464     update_redisplay_ticks (0, NULL);
 17465 
 17466   unbind_to (count, Qnil);
 17467   RESUME_POLLING;
 17468 }
 17469 
 17470 static void
 17471 unwind_redisplay_preserve_echo_area (void)
 17472 {
 17473   unblock_buffer_flips ();
 17474 }
 17475 
 17476 /* Redisplay, but leave alone any recent echo area message unless
 17477    another message has been requested in its place.
 17478 
 17479    This is useful in situations where you need to redisplay but no
 17480    user action has occurred, making it inappropriate for the message
 17481    area to be cleared.  See tracking_off and
 17482    wait_reading_process_output for examples of these situations.
 17483 
 17484    FROM_WHERE is an integer saying from where this function was
 17485    called.  This is useful for debugging.  */
 17486 
 17487 void
 17488 redisplay_preserve_echo_area (int from_where)
 17489 {
 17490   redisplay_trace ("redisplay_preserve_echo_area (%d)\n", from_where);
 17491 
 17492   block_input ();
 17493   specpdl_ref count = SPECPDL_INDEX ();
 17494   record_unwind_protect_void (unwind_redisplay_preserve_echo_area);
 17495   block_buffer_flips ();
 17496   unblock_input ();
 17497 
 17498   if (!NILP (echo_area_buffer[1]))
 17499     {
 17500       /* We have a previously displayed message, but no current
 17501          message.  Redisplay the previous message.  */
 17502       display_last_displayed_message_p = true;
 17503       redisplay_internal ();
 17504       display_last_displayed_message_p = false;
 17505     }
 17506   else
 17507     redisplay_internal ();
 17508 
 17509   flush_frame (SELECTED_FRAME ());
 17510   unbind_to (count, Qnil);
 17511 }
 17512 
 17513 
 17514 /* Function registered with record_unwind_protect in redisplay_internal.  */
 17515 
 17516 static void
 17517 unwind_redisplay (void)
 17518 {
 17519   redisplaying_p = false;
 17520   unblock_buffer_flips ();
 17521 }
 17522 
 17523 /* Function registered with record_unwind_protect before calling
 17524    start_display outside of redisplay_internal.  */
 17525 void
 17526 unwind_display_working_on_window (void)
 17527 {
 17528   display_working_on_window_p = false;
 17529 }
 17530 
 17531 /* Mark the display of leaf window W as accurate or inaccurate.
 17532    If ACCURATE_P, mark display of W as accurate.
 17533    If !ACCURATE_P, arrange for W to be redisplayed the next
 17534    time redisplay_internal is called.  */
 17535 
 17536 static void
 17537 mark_window_display_accurate_1 (struct window *w, bool accurate_p)
 17538 {
 17539   struct buffer *b = XBUFFER (w->contents);
 17540 #ifdef HAVE_TEXT_CONVERSION
 17541   ptrdiff_t prev_point, prev_mark;
 17542 #endif /* HAVE_TEXT_CONVERSION */
 17543 
 17544   w->last_modified = accurate_p ? BUF_MODIFF (b) : 0;
 17545   w->last_overlay_modified = accurate_p ? BUF_OVERLAY_MODIFF (b) : 0;
 17546   w->last_had_star = BUF_MODIFF (b) > BUF_SAVE_MODIFF (b);
 17547 
 17548   if (accurate_p)
 17549     {
 17550       b->clip_changed = false;
 17551       b->prevent_redisplay_optimizations_p = false;
 17552       eassert (buffer_window_count (b) > 0);
 17553       /* Resetting b->text->redisplay is problematic!
 17554          In order to make it safer to do it here, redisplay_internal must
 17555          have copied all b->text->redisplay to their respective windows.  */
 17556       b->text->redisplay = false;
 17557 
 17558       BUF_UNCHANGED_MODIFIED (b) = BUF_MODIFF (b);
 17559       BUF_OVERLAY_UNCHANGED_MODIFIED (b) = BUF_OVERLAY_MODIFF (b);
 17560       BUF_BEG_UNCHANGED (b) = BUF_GPT (b) - BUF_BEG (b);
 17561       BUF_END_UNCHANGED (b) = BUF_Z (b) - BUF_GPT (b);
 17562 
 17563       w->current_matrix->buffer = b;
 17564       w->current_matrix->begv = BUF_BEGV (b);
 17565       w->current_matrix->zv = BUF_ZV (b);
 17566       w->current_matrix->header_line_p = window_wants_header_line (w);
 17567       w->current_matrix->tab_line_p = window_wants_tab_line (w);
 17568 
 17569       w->last_cursor_vpos = w->cursor.vpos;
 17570       w->last_cursor_off_p = w->cursor_off_p;
 17571 
 17572 #ifdef HAVE_TEXT_CONVERSION
 17573       prev_point = w->last_point;
 17574       prev_mark = w->last_mark;
 17575 #endif /* HAVE_TEXT_CONVERSION */
 17576 
 17577       if (w == XWINDOW (selected_window))
 17578         w->last_point = BUF_PT (b);
 17579       else
 17580         w->last_point = marker_position (w->pointm);
 17581 
 17582       /* w->last_mark is recorded for text conversion purposes.
 17583          Input methods aren't interested in the value of the mark
 17584          if it is inactive, so set it to -1 if it's not.  */
 17585 
 17586       if (XMARKER (BVAR (b, mark))->buffer == b
 17587           && !NILP (BVAR (b, mark_active)))
 17588         w->last_mark = marker_position (BVAR (b, mark));
 17589       else
 17590         w->last_mark = -1;
 17591 
 17592 #ifdef HAVE_TEXT_CONVERSION
 17593       /* See the description of this field in struct window.  */
 17594       w->ephemeral_last_point = w->last_point;
 17595 
 17596       /* Point motion is only propagated to the input method for use
 17597          in text conversion during a redisplay.  While this can lead
 17598          to inconsistencies when point has moved but the change has
 17599          not yet been displayed, it leads to better results most of
 17600          the time, as point often changes within calls to
 17601          `save-excursion', and the only way to detect such calls is to
 17602          observe that the next redisplay never ends with those changes
 17603          applied.
 17604 
 17605          Changes to buffer text are immediately propagated to the
 17606          input method, and the position of point is also updated
 17607          during such a change, so the consequences are not that
 17608          severe.  */
 17609 
 17610       if ((prev_point != w->last_point
 17611            || prev_mark != w->last_mark)
 17612           && FRAME_WINDOW_P (WINDOW_XFRAME (w))
 17613           && w == XWINDOW (WINDOW_XFRAME (w)->selected_window))
 17614         report_point_change (WINDOW_XFRAME (w), w, b);
 17615 #endif /* HAVE_TEXT_CONVERSION */
 17616 
 17617       w->window_end_valid = true;
 17618       w->update_mode_line = false;
 17619       w->preserve_vscroll_p = false;
 17620     }
 17621 
 17622   w->redisplay = !accurate_p;
 17623 }
 17624 
 17625 
 17626 /* Mark the display of windows in the window tree rooted at WINDOW as
 17627    accurate or inaccurate.  If ACCURATE_P, mark display of
 17628    windows as accurate.  If !ACCURATE_P, arrange for windows to
 17629    be redisplayed the next time redisplay_internal is called.  */
 17630 
 17631 void
 17632 mark_window_display_accurate (Lisp_Object window, bool accurate_p)
 17633 {
 17634   struct window *w;
 17635 
 17636   for (; !NILP (window); window = w->next)
 17637     {
 17638       w = XWINDOW (window);
 17639       if (WINDOWP (w->contents))
 17640         mark_window_display_accurate (w->contents, accurate_p);
 17641       else
 17642         mark_window_display_accurate_1 (w, accurate_p);
 17643     }
 17644 
 17645   if (accurate_p)
 17646     update_overlay_arrows (1);
 17647   else
 17648     /* Force a thorough redisplay the next time by setting
 17649        last_arrow_position and last_arrow_string to t, which is
 17650        unequal to any useful value of Voverlay_arrow_...  */
 17651     update_overlay_arrows (-1);
 17652 }
 17653 
 17654 
 17655 /* Return value in display table DP (Lisp_Char_Table *) for character
 17656    C.  Since a display table doesn't have any parent, we don't have to
 17657    follow parent.  Do not call this function directly but use the
 17658    macro DISP_CHAR_VECTOR.  */
 17659 
 17660 Lisp_Object
 17661 disp_char_vector (struct Lisp_Char_Table *dp, int c)
 17662 {
 17663   Lisp_Object val;
 17664 
 17665   if (ASCII_CHAR_P (c))
 17666     {
 17667       val = dp->ascii;
 17668       if (SUB_CHAR_TABLE_P (val))
 17669         val = XSUB_CHAR_TABLE (val)->contents[c];
 17670     }
 17671   else
 17672     {
 17673       Lisp_Object table;
 17674 
 17675       XSETCHAR_TABLE (table, dp);
 17676       val = char_table_ref (table, c);
 17677     }
 17678   if (NILP (val))
 17679     val = dp->defalt;
 17680   return val;
 17681 }
 17682 
 17683 static int buffer_flip_blocked_depth;
 17684 
 17685 static void
 17686 block_buffer_flips (void)
 17687 {
 17688   eassert (buffer_flip_blocked_depth >= 0);
 17689   buffer_flip_blocked_depth++;
 17690 }
 17691 
 17692 static void
 17693 unblock_buffer_flips (void)
 17694 {
 17695   eassert (buffer_flip_blocked_depth > 0);
 17696   if (--buffer_flip_blocked_depth == 0)
 17697     {
 17698       Lisp_Object tail, frame;
 17699       block_input ();
 17700       FOR_EACH_FRAME (tail, frame)
 17701         {
 17702           struct frame *f = XFRAME (frame);
 17703           if (FRAME_TERMINAL (f)->buffer_flipping_unblocked_hook)
 17704             (*FRAME_TERMINAL (f)->buffer_flipping_unblocked_hook) (f);
 17705         }
 17706       unblock_input ();
 17707     }
 17708 }
 17709 
 17710 bool
 17711 buffer_flipping_blocked_p (void)
 17712 {
 17713   return buffer_flip_blocked_depth > 0;
 17714 }
 17715 
 17716 
 17717 /***********************************************************************
 17718                            Window Redisplay
 17719  ***********************************************************************/
 17720 
 17721 /* Redisplay all leaf windows in the window tree rooted at WINDOW.  */
 17722 
 17723 static void
 17724 redisplay_windows (Lisp_Object window)
 17725 {
 17726   while (!NILP (window))
 17727     {
 17728       struct window *w = XWINDOW (window);
 17729 
 17730       if (WINDOWP (w->contents))
 17731         redisplay_windows (w->contents);
 17732       else if (BUFFERP (w->contents))
 17733         {
 17734           displayed_buffer = XBUFFER (w->contents);
 17735           /* Use list_of_error, not Qerror, so that
 17736              we catch only errors and don't run the debugger.  */
 17737           internal_condition_case_1 (redisplay_window_0, window,
 17738                                      list_of_error,
 17739                                      redisplay_window_error);
 17740         }
 17741 
 17742       window = w->next;
 17743     }
 17744 }
 17745 
 17746 static Lisp_Object
 17747 redisplay_window_error (Lisp_Object error_data)
 17748 {
 17749   displayed_buffer->display_error_modiff = BUF_MODIFF (displayed_buffer);
 17750 
 17751   /* When in redisplay, the error is captured and not shown.  Arrange
 17752      for it to be shown later.  */
 17753   if (max_redisplay_ticks > 0
 17754       && CONSP (error_data)
 17755       && EQ (XCAR (error_data), Qerror)
 17756       && STRINGP (XCAR (XCDR (error_data))))
 17757     Vdelayed_warnings_list = Fcons (list2 (XCAR (error_data),
 17758                                            XCAR (XCDR (error_data))),
 17759                                     Vdelayed_warnings_list);
 17760   return Qnil;
 17761 }
 17762 
 17763 static Lisp_Object
 17764 redisplay_window_0 (Lisp_Object window)
 17765 {
 17766   if (displayed_buffer->display_error_modiff < BUF_MODIFF (displayed_buffer))
 17767     redisplay_window (window, false);
 17768   return Qnil;
 17769 }
 17770 
 17771 static Lisp_Object
 17772 redisplay_window_1 (Lisp_Object window)
 17773 {
 17774   if (displayed_buffer->display_error_modiff < BUF_MODIFF (displayed_buffer))
 17775     redisplay_window (window, true);
 17776   return Qnil;
 17777 }
 17778 
 17779 
 17780 /***********************************************************************
 17781                       Aborting runaway redisplay
 17782  ***********************************************************************/
 17783 
 17784 /* Update the redisplay-tick count for window W, and signal an error
 17785    if the tick count is above some threshold, indicating that
 17786    redisplay of the window takes "too long".
 17787 
 17788    TICKS is the amount of ticks to add to the W's current count; zero
 17789    means to initialize the tick count to zero.
 17790 
 17791    W can be NULL if TICKS is zero: that means unconditionally
 17792    re-initialize the current tick count to zero.
 17793 
 17794    W can also be NULL if the caller doesn't know which window is being
 17795    processed by the display code.  In that case, if TICKS is non-zero,
 17796    we assume it's the last window that shows the current buffer.  */
 17797 void
 17798 update_redisplay_ticks (int ticks, struct window *w)
 17799 {
 17800   /* This keeps track of the window on which redisplay is working.  */
 17801   static struct window *cwindow;
 17802   static EMACS_INT window_ticks;
 17803 
 17804   /* We only initialize the count if this is a different window or
 17805      NULL.  Otherwise, this is a call from init_iterator for the same
 17806      window we tracked before, and we should keep the count.  */
 17807   if (!ticks && w != cwindow)
 17808     {
 17809       cwindow = w;
 17810       window_ticks = 0;
 17811     }
 17812   /* Some callers can be run in contexts unrelated to display code, so
 17813      don't abort them and don't update the tick count in those cases.  */
 17814   if ((!w && !redisplaying_p && !display_working_on_window_p)
 17815       /* We never disable redisplay of a mini-window, since that is
 17816          absolutely essential for communicating with Emacs.  */
 17817       || (w && MINI_WINDOW_P (w)))
 17818     return;
 17819 
 17820   if (ticks > 0)
 17821     window_ticks += ticks;
 17822   if (max_redisplay_ticks > 0 && window_ticks > max_redisplay_ticks)
 17823     {
 17824       /* In addition to a buffer, this could be a window (for non-leaf
 17825          windows, not expected here) or nil (for pseudo-windows like
 17826          the one used for the native tool bar).  */
 17827       Lisp_Object contents = w ? w->contents : Qnil;
 17828       char *bufname =
 17829         NILP (contents)
 17830         ? SSDATA (BVAR (current_buffer, name))
 17831         : (BUFFERP (contents)
 17832            ? SSDATA (BVAR (XBUFFER (contents), name))
 17833            : (char *) "<unknown>");
 17834 
 17835       windows_or_buffers_changed = 177;
 17836       /* scrolling_window depends too much on the glyph matrices being
 17837          correct, and we cannot guarantee that if we abort the
 17838          redisplay of this window.  */
 17839       if (w && w->desired_matrix)
 17840         w->desired_matrix->no_scrolling_p = true;
 17841       error ("Window showing buffer %s takes too long to redisplay", bufname);
 17842     }
 17843 }
 17844 
 17845 
 17846 
 17847 /* Set cursor position of W.  PT is assumed to be displayed in ROW.
 17848    DELTA and DELTA_BYTES are the numbers of characters and bytes by
 17849    which positions recorded in ROW differ from current buffer
 17850    positions.
 17851 
 17852    Return true iff cursor is on this row.  */
 17853 
 17854 static bool
 17855 set_cursor_from_row (struct window *w, struct glyph_row *row,
 17856                      struct glyph_matrix *matrix,
 17857                      ptrdiff_t delta, ptrdiff_t delta_bytes,
 17858                      int dy, int dvpos)
 17859 {
 17860   struct glyph *glyph = row->glyphs[TEXT_AREA];
 17861   struct glyph *end = glyph + row->used[TEXT_AREA];
 17862   struct glyph *cursor = NULL;
 17863   /* The last known character position in row.  */
 17864   ptrdiff_t last_pos = MATRIX_ROW_START_CHARPOS (row) + delta;
 17865   int x = row->x;
 17866   ptrdiff_t pt_old = PT - delta;
 17867   ptrdiff_t pos_before = MATRIX_ROW_START_CHARPOS (row) + delta;
 17868   ptrdiff_t pos_after = MATRIX_ROW_END_CHARPOS (row) + delta;
 17869   struct glyph *glyph_before = glyph - 1, *glyph_after = end;
 17870   /* A glyph beyond the edge of TEXT_AREA which we should never
 17871      touch.  */
 17872   struct glyph *glyphs_end = end;
 17873   /* True means we've found a match for cursor position, but that
 17874      glyph has the avoid_cursor_p flag set.  */
 17875   bool match_with_avoid_cursor = false;
 17876   /* True means we've seen at least one glyph that came from a
 17877      display string.  */
 17878   bool string_seen = false;
 17879   /* Largest and smallest buffer positions seen so far during scan of
 17880      glyph row.  */
 17881   ptrdiff_t bpos_max = pos_before;
 17882   ptrdiff_t bpos_min = pos_after;
 17883   /* Last buffer position covered by an overlay string with an integer
 17884      `cursor' property.  */
 17885   ptrdiff_t bpos_covered = 0;
 17886   /* True means the display string on which to display the cursor
 17887      comes from a text property, not from an overlay.  */
 17888   bool string_from_text_prop = false;
 17889 
 17890   /* Don't even try doing anything if called for a mode-line or
 17891      header-line or tab-line row, since the rest of the code isn't
 17892      prepared to deal with such calamities.  */
 17893   eassert (!row->mode_line_p);
 17894   if (row->mode_line_p)
 17895     return false;
 17896 
 17897   /* Skip over glyphs not having an object at the start and the end of
 17898      the row.  These are special glyphs like truncation marks on
 17899      terminal frames.  */
 17900   if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
 17901     {
 17902       if (!row->reversed_p)
 17903         {
 17904           while (glyph < end
 17905                  && NILP (glyph->object)
 17906                  && glyph->charpos < 0)
 17907             {
 17908               x += glyph->pixel_width;
 17909               ++glyph;
 17910             }
 17911           while (end > glyph
 17912                  && NILP ((end - 1)->object)
 17913                  /* CHARPOS is zero for blanks and stretch glyphs
 17914                     inserted by extend_face_to_end_of_line.  */
 17915                  && (end - 1)->charpos <= 0)
 17916             --end;
 17917           glyph_before = glyph - 1;
 17918           glyph_after = end;
 17919         }
 17920       else
 17921         {
 17922           struct glyph *g;
 17923 
 17924           /* If the glyph row is reversed, we need to process it from back
 17925              to front, so swap the edge pointers.  */
 17926           glyphs_end = end = glyph - 1;
 17927           glyph += row->used[TEXT_AREA] - 1;
 17928 
 17929           while (glyph > end + 1
 17930                  && NILP (glyph->object)
 17931                  && glyph->charpos < 0)
 17932             --glyph;
 17933           if (NILP (glyph->object) && glyph->charpos < 0)
 17934             --glyph;
 17935           /* By default, in reversed rows we put the cursor on the
 17936              rightmost (first in the reading order) glyph.  */
 17937           for (x = 0, g = end + 1; g < glyph; g++)
 17938             x += g->pixel_width;
 17939           while (end < glyph
 17940                  && NILP ((end + 1)->object)
 17941                  && (end + 1)->charpos <= 0)
 17942             ++end;
 17943           glyph_before = glyph + 1;
 17944           glyph_after = end;
 17945         }
 17946     }
 17947   else if (row->reversed_p)
 17948     {
 17949       /* In R2L rows that don't display text, put the cursor on the
 17950          rightmost glyph.  Case in point: an empty last line that is
 17951          part of an R2L paragraph.  */
 17952       cursor = end - 1;
 17953       /* Avoid placing the cursor on the last glyph of the row, where
 17954          on terminal frames we hold the vertical border between
 17955          adjacent windows.  */
 17956       if (!FRAME_WINDOW_P (WINDOW_XFRAME (w))
 17957           && !WINDOW_RIGHTMOST_P (w)
 17958           && cursor == row->glyphs[LAST_AREA] - 1)
 17959         cursor--;
 17960       x = -1;   /* will be computed below, at label compute_x */
 17961     }
 17962 
 17963   /* Step 1: Try to find the glyph whose character position
 17964      corresponds to point.  If that's not possible, find 2 glyphs
 17965      whose character positions are the closest to point, one before
 17966      point, the other after it.  */
 17967   if (!row->reversed_p)
 17968     while (/* not marched to end of glyph row */
 17969            glyph < end
 17970            /* glyph was not inserted by redisplay for internal purposes */
 17971            && !NILP (glyph->object))
 17972       {
 17973         if (BUFFERP (glyph->object))
 17974           {
 17975             ptrdiff_t dpos = glyph->charpos - pt_old;
 17976 
 17977             if (glyph->charpos > bpos_max)
 17978               bpos_max = glyph->charpos;
 17979             if (glyph->charpos < bpos_min)
 17980               bpos_min = glyph->charpos;
 17981             if (!glyph->avoid_cursor_p)
 17982               {
 17983                 /* If we hit point, we've found the glyph on which to
 17984                    display the cursor.  */
 17985                 if (dpos == 0)
 17986                   {
 17987                     match_with_avoid_cursor = false;
 17988                     break;
 17989                   }
 17990                 /* See if we've found a better approximation to
 17991                    POS_BEFORE or to POS_AFTER.  */
 17992                 if (0 > dpos && dpos > pos_before - pt_old)
 17993                   {
 17994                     pos_before = glyph->charpos;
 17995                     glyph_before = glyph;
 17996                   }
 17997                 else if (0 < dpos && dpos < pos_after - pt_old)
 17998                   {
 17999                     pos_after = glyph->charpos;
 18000                     glyph_after = glyph;
 18001                   }
 18002               }
 18003             else if (dpos == 0)
 18004               match_with_avoid_cursor = true;
 18005           }
 18006         else if (STRINGP (glyph->object))
 18007           {
 18008             Lisp_Object chprop;
 18009             ptrdiff_t glyph_pos = glyph->charpos;
 18010 
 18011             chprop = Fget_char_property (make_fixnum (glyph_pos), Qcursor,
 18012                                          glyph->object);
 18013             if (!NILP (chprop))
 18014               {
 18015                 /* If the string came from a `display' text property,
 18016                    look up the buffer position of that property and
 18017                    use that position to update bpos_max, as if we
 18018                    actually saw such a position in one of the row's
 18019                    glyphs.  This helps with supporting integer values
 18020                    of `cursor' property on the display string in
 18021                    situations where most or all of the row's buffer
 18022                    text is completely covered by display properties,
 18023                    so that no glyph with valid buffer positions is
 18024                    ever seen in the row.  */
 18025                 ptrdiff_t prop_pos =
 18026                   string_buffer_position_lim (glyph->object, pos_before,
 18027                                               pos_after, false);
 18028 
 18029                 if (prop_pos >= pos_before)
 18030                   bpos_max = prop_pos;
 18031               }
 18032             if (FIXNUMP (chprop))
 18033               {
 18034                 bpos_covered = bpos_max + XFIXNUM (chprop);
 18035                 /* If the `cursor' property covers buffer positions up
 18036                    to and including point, we should display cursor on
 18037                    this glyph.  Note that, if a `cursor' property on one
 18038                    of the string's characters has an integer value, we
 18039                    will break out of the loop below _before_ we get to
 18040                    the position match above.  IOW, integer values of
 18041                    the `cursor' property override the "exact match for
 18042                    point" strategy of positioning the cursor.  */
 18043                 /* Implementation note: bpos_max == pt_old when, e.g.,
 18044                    we are in an empty line, where bpos_max is set to
 18045                    MATRIX_ROW_START_CHARPOS, see above.  */
 18046                 if (bpos_max <= pt_old && bpos_covered >= pt_old)
 18047                   {
 18048                     cursor = glyph;
 18049                     break;
 18050                   }
 18051               }
 18052 
 18053             string_seen = true;
 18054           }
 18055         x += glyph->pixel_width;
 18056         ++glyph;
 18057       }
 18058   else if (glyph > end) /* row is reversed */
 18059     while (!NILP (glyph->object))
 18060       {
 18061         if (BUFFERP (glyph->object))
 18062           {
 18063             ptrdiff_t dpos = glyph->charpos - pt_old;
 18064 
 18065             if (glyph->charpos > bpos_max)
 18066               bpos_max = glyph->charpos;
 18067             if (glyph->charpos < bpos_min)
 18068               bpos_min = glyph->charpos;
 18069             if (!glyph->avoid_cursor_p)
 18070               {
 18071                 if (dpos == 0)
 18072                   {
 18073                     match_with_avoid_cursor = false;
 18074                     break;
 18075                   }
 18076                 if (0 > dpos && dpos > pos_before - pt_old)
 18077                   {
 18078                     pos_before = glyph->charpos;
 18079                     glyph_before = glyph;
 18080                   }
 18081                 else if (0 < dpos && dpos < pos_after - pt_old)
 18082                   {
 18083                     pos_after = glyph->charpos;
 18084                     glyph_after = glyph;
 18085                   }
 18086               }
 18087             else if (dpos == 0)
 18088               match_with_avoid_cursor = true;
 18089           }
 18090         else if (STRINGP (glyph->object))
 18091           {
 18092             Lisp_Object chprop;
 18093             ptrdiff_t glyph_pos = glyph->charpos;
 18094 
 18095             chprop = Fget_char_property (make_fixnum (glyph_pos), Qcursor,
 18096                                          glyph->object);
 18097             if (!NILP (chprop))
 18098               {
 18099                 ptrdiff_t prop_pos =
 18100                   string_buffer_position_lim (glyph->object, pos_before,
 18101                                               pos_after, false);
 18102 
 18103                 if (prop_pos >= pos_before)
 18104                   bpos_max = prop_pos;
 18105               }
 18106             if (FIXNUMP (chprop))
 18107               {
 18108                 bpos_covered = bpos_max + XFIXNUM (chprop);
 18109                 /* If the `cursor' property covers buffer positions up
 18110                    to and including point, we should display cursor on
 18111                    this glyph.  */
 18112                 if (bpos_max <= pt_old && bpos_covered >= pt_old)
 18113                   {
 18114                     cursor = glyph;
 18115                     break;
 18116                   }
 18117               }
 18118             string_seen = true;
 18119           }
 18120         --glyph;
 18121         if (glyph == glyphs_end) /* don't dereference outside TEXT_AREA */
 18122           {
 18123             x--;                /* can't use any pixel_width */
 18124             break;
 18125           }
 18126         x -= glyph->pixel_width;
 18127     }
 18128 
 18129   /* Step 2: If we didn't find an exact match for point, we need to
 18130      look for a proper place to put the cursor among glyphs between
 18131      GLYPH_BEFORE and GLYPH_AFTER.  */
 18132   if (!((row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end)
 18133         && BUFFERP (glyph->object) && glyph->charpos == pt_old)
 18134       && !(bpos_max <= pt_old && pt_old <= bpos_covered))
 18135     {
 18136       /* An empty line has a single glyph whose OBJECT is nil and
 18137          whose CHARPOS is the position of a newline on that line.
 18138          Note that on a TTY, there are more glyphs after that, which
 18139          were produced by extend_face_to_end_of_line, but their
 18140          CHARPOS is zero or negative.  */
 18141       bool empty_line_p =
 18142         ((row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end)
 18143          && NILP (glyph->object) && glyph->charpos > 0
 18144          /* On a TTY, continued and truncated rows also have a glyph at
 18145             their end whose OBJECT is nil and whose CHARPOS is
 18146             positive (the continuation and truncation glyphs), but such
 18147             rows are obviously not "empty".  */
 18148          && !(row->continued_p || row->truncated_on_right_p));
 18149 
 18150       if (row->ends_in_ellipsis_p && pos_after == last_pos)
 18151         {
 18152           ptrdiff_t ellipsis_pos;
 18153 
 18154           /* Scan back over the ellipsis glyphs.  */
 18155           if (!row->reversed_p)
 18156             {
 18157               ellipsis_pos = (glyph - 1)->charpos;
 18158               while (glyph > row->glyphs[TEXT_AREA]
 18159                      && (glyph - 1)->charpos == ellipsis_pos)
 18160                 glyph--, x -= glyph->pixel_width;
 18161               /* That loop always goes one position too far, including
 18162                  the glyph before the ellipsis.  So scan forward over
 18163                  that one.  */
 18164               x += glyph->pixel_width;
 18165               glyph++;
 18166             }
 18167           else  /* row is reversed */
 18168             {
 18169               ellipsis_pos = (glyph + 1)->charpos;
 18170               while (glyph < row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1
 18171                      && (glyph + 1)->charpos == ellipsis_pos)
 18172                 glyph++, x += glyph->pixel_width;
 18173               x -= glyph->pixel_width;
 18174               glyph--;
 18175             }
 18176         }
 18177       else if (match_with_avoid_cursor)
 18178         {
 18179           cursor = glyph_after;
 18180           x = -1;
 18181         }
 18182       else if (string_seen)
 18183         {
 18184           int incr = row->reversed_p ? -1 : +1;
 18185 
 18186           /* Need to find the glyph that came out of a string which is
 18187              present at point.  That glyph is somewhere between
 18188              GLYPH_BEFORE and GLYPH_AFTER, and it came from a string
 18189              positioned between POS_BEFORE and POS_AFTER in the
 18190              buffer.  */
 18191           struct glyph *start, *stop;
 18192           ptrdiff_t pos = pos_before;
 18193 
 18194           x = -1;
 18195 
 18196           /* If the row ends in a newline from a display string,
 18197              reordering could have moved the glyphs belonging to the
 18198              string out of the [GLYPH_BEFORE..GLYPH_AFTER] range.  So
 18199              in this case we extend the search to the last glyph in
 18200              the row that was not inserted by redisplay.  */
 18201           if (row->ends_in_newline_from_string_p)
 18202             {
 18203               glyph_after = end;
 18204               pos_after = MATRIX_ROW_END_CHARPOS (row) + delta;
 18205             }
 18206 
 18207           /* GLYPH_BEFORE and GLYPH_AFTER are the glyphs that
 18208              correspond to POS_BEFORE and POS_AFTER, respectively.  We
 18209              need START and STOP in the order that corresponds to the
 18210              row's direction as given by its reversed_p flag.  If the
 18211              directionality of characters between POS_BEFORE and
 18212              POS_AFTER is the opposite of the row's base direction,
 18213              these characters will have been reordered for display,
 18214              and we need to reverse START and STOP.  */
 18215           if (!row->reversed_p)
 18216             {
 18217               start = min (glyph_before, glyph_after);
 18218               stop = max (glyph_before, glyph_after);
 18219             }
 18220           else
 18221             {
 18222               start = max (glyph_before, glyph_after);
 18223               stop = min (glyph_before, glyph_after);
 18224             }
 18225           for (glyph = start + incr;
 18226                row->reversed_p ? glyph > stop : glyph < stop; )
 18227             {
 18228 
 18229               /* Any glyphs that come from the buffer are here because
 18230                  of bidi reordering.  Skip them, and only pay
 18231                  attention to glyphs that came from some string.  */
 18232               if (STRINGP (glyph->object))
 18233                 {
 18234                   Lisp_Object str;
 18235                   ptrdiff_t tem;
 18236                   /* If the display property covers the newline, we
 18237                      need to search for it one position farther.  */
 18238                   ptrdiff_t lim = pos_after
 18239                     + (pos_after == MATRIX_ROW_END_CHARPOS (row) + delta);
 18240 
 18241                   string_from_text_prop = false;
 18242                   str = glyph->object;
 18243                   tem = string_buffer_position_lim (str, pos, lim, false);
 18244                   if (tem == 0  /* from overlay */
 18245                       || pos <= tem)
 18246                     {
 18247                       /* If the string from which this glyph came is
 18248                          found in the buffer at point, or at position
 18249                          that is closer to point than pos_after, then
 18250                          we've found the glyph we've been looking for.
 18251                          If it comes from an overlay (tem == 0), and
 18252                          it has the `cursor' property on one of its
 18253                          glyphs, record that glyph as a candidate for
 18254                          displaying the cursor.  (As in the
 18255                          unidirectional version, we will display the
 18256                          cursor on the last candidate we find.)  */
 18257                       if (tem == 0
 18258                           || tem == pt_old
 18259                           || (tem - pt_old > 0 && tem < pos_after))
 18260                         {
 18261                           /* The glyphs from this string could have
 18262                              been reordered.  Find the one with the
 18263                              smallest string position.  Or there could
 18264                              be a character in the string with the
 18265                              `cursor' property, which means display
 18266                              cursor on that character's glyph.  */
 18267                           ptrdiff_t strpos = glyph->charpos;
 18268 
 18269                           if (tem)
 18270                             {
 18271                               cursor = glyph;
 18272                               string_from_text_prop = true;
 18273                             }
 18274                           for ( ;
 18275                                (row->reversed_p ? glyph > stop : glyph < stop)
 18276                                  && EQ (glyph->object, str);
 18277                                glyph += incr)
 18278                             {
 18279                               Lisp_Object cprop;
 18280                               ptrdiff_t gpos = glyph->charpos;
 18281 
 18282                               cprop = Fget_char_property (make_fixnum (gpos),
 18283                                                           Qcursor,
 18284                                                           glyph->object);
 18285                               if (!NILP (cprop))
 18286                                 {
 18287                                   cursor = glyph;
 18288                                   break;
 18289                                 }
 18290                               if (tem && glyph->charpos < strpos)
 18291                                 {
 18292                                   strpos = glyph->charpos;
 18293                                   cursor = glyph;
 18294                                 }
 18295                             }
 18296 
 18297                           if (tem == pt_old
 18298                               || (tem - pt_old > 0 && tem < pos_after))
 18299                             goto compute_x;
 18300                         }
 18301                       if (tem)
 18302                         pos = tem + 1; /* don't find previous instances */
 18303                     }
 18304                   /* This string is not what we want; skip all of the
 18305                      glyphs that came from it.  */
 18306                   while ((row->reversed_p ? glyph > stop : glyph < stop)
 18307                          && EQ (glyph->object, str))
 18308                     glyph += incr;
 18309                 }
 18310               else
 18311                 glyph += incr;
 18312             }
 18313 
 18314           /* If we reached the end of the line, and END was from a string,
 18315              the cursor is not on this line.  */
 18316           if (cursor == NULL
 18317               && (row->reversed_p ? glyph <= end : glyph >= end)
 18318               && (row->reversed_p ? end > glyphs_end : end < glyphs_end)
 18319               && STRINGP (end->object)
 18320               && row->continued_p)
 18321             return false;
 18322         }
 18323       /* A truncated row may not include PT among its character positions.
 18324          Setting the cursor inside the scroll margin will trigger
 18325          recalculation of hscroll in hscroll_window_tree.  But if a
 18326          display string covers point, defer to the string-handling
 18327          code below to figure this out.  */
 18328       else if (row->truncated_on_left_p && pt_old < bpos_min)
 18329         {
 18330           cursor = glyph_before;
 18331           x = -1;
 18332         }
 18333       else if ((row->truncated_on_right_p && pt_old > bpos_max)
 18334                /* Zero-width characters produce no glyphs.  */
 18335                || (!empty_line_p
 18336                    && (row->reversed_p
 18337                        ? glyph_after > glyphs_end
 18338                        : glyph_after < glyphs_end)))
 18339         {
 18340           cursor = glyph_after;
 18341           x = -1;
 18342         }
 18343     }
 18344 
 18345  compute_x:
 18346   if (cursor != NULL)
 18347     glyph = cursor;
 18348   else if (glyph == glyphs_end
 18349            && pos_before == pos_after
 18350            && STRINGP ((row->reversed_p
 18351                         ? row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1
 18352                         : row->glyphs[TEXT_AREA])->object))
 18353     {
 18354       /* If all the glyphs of this row came from strings, put the
 18355          cursor on the first glyph of the row.  This avoids having the
 18356          cursor outside of the text area in this very rare and hard
 18357          use case.  */
 18358       glyph =
 18359         row->reversed_p
 18360         ? row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1
 18361         : row->glyphs[TEXT_AREA];
 18362     }
 18363   if (x < 0)
 18364     {
 18365       struct glyph *g;
 18366 
 18367       /* Need to compute x that corresponds to GLYPH.  */
 18368       for (g = row->glyphs[TEXT_AREA], x = row->x; g < glyph; g++)
 18369         {
 18370           if (g >= row->glyphs[TEXT_AREA] + row->used[TEXT_AREA])
 18371             emacs_abort ();
 18372           x += g->pixel_width;
 18373         }
 18374     }
 18375 
 18376   /* ROW could be part of a continued line, which, under bidi
 18377      reordering, might have other rows whose start and end charpos
 18378      occlude point.  Only set w->cursor if we found a better
 18379      approximation to the cursor position than we have from previously
 18380      examined candidate rows belonging to the same continued line.  */
 18381   if (/* We already have a candidate row.  */
 18382       w->cursor.vpos >= 0
 18383       /* That candidate is not the row we are processing.  */
 18384       && MATRIX_ROW (matrix, w->cursor.vpos) != row
 18385       /* Make sure cursor.vpos specifies a row whose start and end
 18386          charpos occlude point, and it is valid candidate for being a
 18387          cursor-row.  This is because some callers of this function
 18388          leave cursor.vpos at the row where the cursor was displayed
 18389          during the last redisplay cycle.  */
 18390       && MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos)) <= pt_old
 18391       && pt_old <= MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos))
 18392       && cursor_row_p (MATRIX_ROW (matrix, w->cursor.vpos)))
 18393     {
 18394       struct glyph *g1
 18395         = MATRIX_ROW_GLYPH_START (matrix, w->cursor.vpos) + w->cursor.hpos;
 18396 
 18397       /* Don't consider glyphs that are outside TEXT_AREA.  */
 18398       if (!(row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end))
 18399         return false;
 18400       /* Keep the candidate whose buffer position is the closest to
 18401          point or has the `cursor' property.  */
 18402       if (/* Previous candidate is a glyph in TEXT_AREA of that row.  */
 18403           w->cursor.hpos >= 0
 18404           && w->cursor.hpos < MATRIX_ROW_USED (matrix, w->cursor.vpos)
 18405           && ((BUFFERP (g1->object)
 18406                && (g1->charpos == pt_old /* An exact match always wins.  */
 18407                    || (BUFFERP (glyph->object)
 18408                        && eabs (g1->charpos - pt_old)
 18409                        < eabs (glyph->charpos - pt_old))))
 18410               /* Previous candidate is a glyph from a string that has
 18411                  a non-nil `cursor' property.  */
 18412               || (STRINGP (g1->object)
 18413                   && (!NILP (Fget_char_property (make_fixnum (g1->charpos),
 18414                                                 Qcursor, g1->object))
 18415                       /* Previous candidate is from the same display
 18416                          string as this one, and the display string
 18417                          came from a text property.  */
 18418                       || (EQ (g1->object, glyph->object)
 18419                           && string_from_text_prop)
 18420                       /* this candidate is from newline and its
 18421                          position is not an exact match */
 18422                       || (NILP (glyph->object)
 18423                           && glyph->charpos != pt_old)))))
 18424         return false;
 18425       /* If this candidate gives an exact match, use that.  */
 18426       if (!((BUFFERP (glyph->object) && glyph->charpos == pt_old)
 18427             /* If this candidate is a glyph created for the
 18428                terminating newline of a line, and point is on that
 18429                newline, it wins because it's an exact match.  */
 18430             || (!row->continued_p
 18431                 && NILP (glyph->object)
 18432                 && glyph->charpos == 0
 18433                 && pt_old == MATRIX_ROW_END_CHARPOS (row) - 1))
 18434           /* Otherwise, keep the candidate that comes from a row
 18435              spanning less buffer positions.  This may win when one or
 18436              both candidate positions are on glyphs that came from
 18437              display strings, for which we cannot compare buffer
 18438              positions.  */
 18439           && MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos))
 18440              - MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos))
 18441              < MATRIX_ROW_END_CHARPOS (row) - MATRIX_ROW_START_CHARPOS (row))
 18442         return false;
 18443     }
 18444   w->cursor.hpos = glyph - row->glyphs[TEXT_AREA];
 18445   w->cursor.x = x;
 18446   w->cursor.vpos = MATRIX_ROW_VPOS (row, matrix) + dvpos;
 18447   w->cursor.y = row->y + dy;
 18448 
 18449   if (w == XWINDOW (selected_window))
 18450     {
 18451       if (!row->continued_p
 18452           && !MATRIX_ROW_CONTINUATION_LINE_P (row)
 18453           && row->x == 0)
 18454         {
 18455           this_line_buffer = XBUFFER (w->contents);
 18456 
 18457           CHARPOS (this_line_start_pos)
 18458             = MATRIX_ROW_START_CHARPOS (row) + delta;
 18459           BYTEPOS (this_line_start_pos)
 18460             = MATRIX_ROW_START_BYTEPOS (row) + delta_bytes;
 18461 
 18462           CHARPOS (this_line_end_pos)
 18463             = Z - (MATRIX_ROW_END_CHARPOS (row) + delta);
 18464           BYTEPOS (this_line_end_pos)
 18465             = Z_BYTE - (MATRIX_ROW_END_BYTEPOS (row) + delta_bytes);
 18466 
 18467           this_line_y = w->cursor.y;
 18468           this_line_pixel_height = row->height;
 18469           this_line_vpos = w->cursor.vpos;
 18470           this_line_start_x = row->x;
 18471         }
 18472       else
 18473         CHARPOS (this_line_start_pos) = 0;
 18474     }
 18475 
 18476   return true;
 18477 }
 18478 
 18479 
 18480 /* Run window scroll functions, if any, for WINDOW with new window
 18481    start STARTP.  Sets the window start of WINDOW to that position.
 18482 
 18483    We assume that the window's buffer is really current.  */
 18484 
 18485 static struct text_pos
 18486 run_window_scroll_functions (Lisp_Object window, struct text_pos startp)
 18487 {
 18488   struct window *w = XWINDOW (window);
 18489   SET_MARKER_FROM_TEXT_POS (w->start, startp);
 18490 
 18491   eassert (current_buffer == XBUFFER (w->contents));
 18492 
 18493   if (!NILP (Vwindow_scroll_functions))
 18494     {
 18495       specpdl_ref count = SPECPDL_INDEX ();
 18496       specbind (Qinhibit_quit, Qt);
 18497       safe_run_hooks_2
 18498         (Qwindow_scroll_functions, window, make_fixnum (CHARPOS (startp)));
 18499       unbind_to (count, Qnil);
 18500       SET_TEXT_POS_FROM_MARKER (startp, w->start);
 18501       /* In case the hook functions switch buffers.  */
 18502       set_buffer_internal (XBUFFER (w->contents));
 18503     }
 18504 
 18505   return startp;
 18506 }
 18507 
 18508 
 18509 /* Make sure the line containing the cursor is fully visible.
 18510    A value of true means there is nothing to be done.
 18511    (Either the line is fully visible, or it cannot be made so,
 18512    or we cannot tell.)
 18513 
 18514    If FORCE_P, return false even if partial visible cursor row
 18515    is higher than window.
 18516 
 18517    If CURRENT_MATRIX_P, use the information from the
 18518    window's current glyph matrix; otherwise use the desired glyph
 18519    matrix.
 18520 
 18521    If JUST_TEST_USER_PREFERENCE_P, just test what the value of
 18522    make-cursor-row-fully-visible requires, don't test the actual
 18523    cursor position.  The assumption is that in that case the caller
 18524    performs the necessary testing of the cursor position.
 18525 
 18526    A value of false means the caller should do scrolling
 18527    as if point had gone off the screen.  */
 18528 
 18529 static bool
 18530 cursor_row_fully_visible_p (struct window *w, bool force_p,
 18531                             bool current_matrix_p,
 18532                             bool just_test_user_preference_p)
 18533 {
 18534   struct glyph_matrix *matrix;
 18535   struct glyph_row *row;
 18536   int window_height;
 18537   Lisp_Object mclfv_p =
 18538     buffer_local_value (Qmake_cursor_line_fully_visible, w->contents);
 18539 
 18540   /* If no local binding, use the global value.  */
 18541   if (BASE_EQ (mclfv_p, Qunbound))
 18542     mclfv_p = Vmake_cursor_line_fully_visible;
 18543   /* Follow mode sets the variable to a Lisp function in buffers that
 18544      are under Follow mode.  */
 18545   if (FUNCTIONP (mclfv_p))
 18546     {
 18547       Lisp_Object window;
 18548       XSETWINDOW (window, w);
 18549       /* Implementation note: if the function we call here signals an
 18550          error, we will NOT scroll when the cursor is partially-visible.  */
 18551       Lisp_Object val = safe_call1 (mclfv_p, window);
 18552       if (NILP (val))
 18553         return true;
 18554       else if (just_test_user_preference_p)
 18555         return false;
 18556     }
 18557   else if (NILP (mclfv_p))
 18558     return true;
 18559   else if (just_test_user_preference_p)
 18560     return false;
 18561 
 18562   /* It's not always possible to find the cursor, e.g, when a window
 18563      is full of overlay strings.  Don't do anything in that case.  */
 18564   if (w->cursor.vpos < 0)
 18565     return true;
 18566 
 18567   matrix = current_matrix_p ? w->current_matrix : w->desired_matrix;
 18568   row = MATRIX_ROW (matrix, w->cursor.vpos);
 18569 
 18570   /* If the cursor row is not partially visible, there's nothing to do.  */
 18571   if (!MATRIX_ROW_PARTIALLY_VISIBLE_P (w, row))
 18572     return true;
 18573 
 18574   /* If the row the cursor is in is taller than the window's height,
 18575      it's not clear what to do, so do nothing.  */
 18576   window_height = window_box_height (w);
 18577   if (row->height >= window_height)
 18578     {
 18579       if (!force_p || MINI_WINDOW_P (w)
 18580           || w->vscroll || w->cursor.vpos == 0)
 18581         return true;
 18582     }
 18583   return false;
 18584 }
 18585 
 18586 
 18587 /* Try scrolling PT into view in window WINDOW.  JUST_THIS_ONE_P
 18588    means only WINDOW is redisplayed in redisplay_internal.
 18589    TEMP_SCROLL_STEP has the same meaning as emacs_scroll_step, and is used
 18590    in redisplay_window to bring a partially visible line into view in
 18591    the case that only the cursor has moved.
 18592 
 18593    LAST_LINE_MISFIT should be true if we're scrolling because the
 18594    last screen line's vertical height extends past the end of the screen.
 18595 
 18596    Value is
 18597 
 18598    1    if scrolling succeeded
 18599 
 18600    0    if scrolling didn't find point.
 18601 
 18602    -1   if new fonts have been loaded so that we must interrupt
 18603    redisplay, adjust glyph matrices, and try again.  */
 18604 
 18605 enum
 18606 {
 18607   SCROLLING_SUCCESS = 1,
 18608   SCROLLING_FAILED = 0,
 18609   SCROLLING_NEED_LARGER_MATRICES = -1
 18610 };
 18611 
 18612 /* If scroll-conservatively is more than this, never recenter.
 18613 
 18614    If you change this, don't forget to update the doc string of
 18615    `scroll-conservatively' and the Emacs manual.  */
 18616 #define SCROLL_LIMIT 100
 18617 
 18618 static int
 18619 try_scrolling (Lisp_Object window, bool just_this_one_p,
 18620                intmax_t arg_scroll_conservatively, intmax_t scroll_step,
 18621                bool temp_scroll_step, bool last_line_misfit)
 18622 {
 18623   struct window *w = XWINDOW (window);
 18624   struct text_pos pos, startp;
 18625   struct it it;
 18626   int this_scroll_margin, scroll_max, rc, height;
 18627   int dy = 0, amount_to_scroll = 0;
 18628   bool scroll_down_p = false;
 18629   int extra_scroll_margin_lines = last_line_misfit;
 18630   Lisp_Object aggressive;
 18631   /* We will never try scrolling more than this number of lines.  */
 18632   int scroll_limit = SCROLL_LIMIT;
 18633   int frame_line_height = default_line_pixel_height (w);
 18634 
 18635 #ifdef GLYPH_DEBUG
 18636   debug_method_add (w, "try_scrolling");
 18637 #endif
 18638 
 18639   SET_TEXT_POS_FROM_MARKER (startp, w->start);
 18640 
 18641   this_scroll_margin = window_scroll_margin (w, MARGIN_IN_PIXELS);
 18642 
 18643   /* Force arg_scroll_conservatively to have a reasonable value, to
 18644      avoid scrolling too far away with slow move_it_* functions.  Note
 18645      that the user can supply scroll-conservatively equal to
 18646      `most-positive-fixnum', which can be larger than INT_MAX.  */
 18647   if (arg_scroll_conservatively > scroll_limit)
 18648     {
 18649       arg_scroll_conservatively = scroll_limit + 1;
 18650       scroll_max = scroll_limit * frame_line_height;
 18651     }
 18652   else if (0 < scroll_step || 0 < arg_scroll_conservatively || temp_scroll_step)
 18653     /* Compute how much we should try to scroll maximally to bring
 18654        point into view.  */
 18655     {
 18656       intmax_t scroll_lines_max
 18657         = max (scroll_step, max (arg_scroll_conservatively, temp_scroll_step));
 18658       int scroll_lines = clip_to_bounds (0, scroll_lines_max, 1000000);
 18659       scroll_max = scroll_lines * frame_line_height;
 18660     }
 18661   else if (NUMBERP (BVAR (current_buffer, scroll_down_aggressively))
 18662            || NUMBERP (BVAR (current_buffer, scroll_up_aggressively)))
 18663     /* We're trying to scroll because of aggressive scrolling but no
 18664        scroll_step is set.  Choose an arbitrary one.  */
 18665     scroll_max = 10 * frame_line_height;
 18666   else
 18667     scroll_max = 0;
 18668 
 18669  too_near_end:
 18670 
 18671   /* Decide whether to scroll down.  */
 18672   if (PT > CHARPOS (startp))
 18673     {
 18674       int scroll_margin_y;
 18675 
 18676       /* Compute the pixel ypos of the scroll margin, then move IT to
 18677          either that ypos or PT, whichever comes first.  */
 18678       start_display (&it, w, startp);
 18679       scroll_margin_y = it.last_visible_y - partial_line_height (&it)
 18680         - this_scroll_margin
 18681         - frame_line_height * extra_scroll_margin_lines;
 18682       move_it_to (&it, PT, -1, scroll_margin_y - 1, -1,
 18683                   (MOVE_TO_POS | MOVE_TO_Y));
 18684 
 18685       if (PT > CHARPOS (it.current.pos))
 18686         {
 18687           int y0 = line_bottom_y (&it);
 18688           /* Compute how many pixels below window bottom to stop searching
 18689              for PT.  This avoids costly search for PT that is far away if
 18690              the user limited scrolling by a small number of lines, but
 18691              always finds PT if scroll_conservatively is set to a large
 18692              number, such as most-positive-fixnum.  */
 18693           int slack = max (scroll_max, 10 * frame_line_height);
 18694           int y_to_move = it.last_visible_y + slack;
 18695 
 18696           /* Compute the distance from the scroll margin to PT or to
 18697              the scroll limit, whichever comes first.  This should
 18698              include the height of the cursor line, to make that line
 18699              fully visible.  */
 18700           move_it_to (&it, PT, -1, y_to_move,
 18701                       -1, MOVE_TO_POS | MOVE_TO_Y);
 18702           dy = line_bottom_y (&it) - y0;
 18703 
 18704           if (dy > scroll_max)
 18705             return SCROLLING_FAILED;
 18706 
 18707           if (dy > 0)
 18708             scroll_down_p = true;
 18709         }
 18710       else if (PT == IT_CHARPOS (it)
 18711                && IT_CHARPOS (it) < ZV
 18712                && it.method == GET_FROM_STRING
 18713                && arg_scroll_conservatively > scroll_limit
 18714                && it.current_x == 0)
 18715         {
 18716           enum move_it_result skip;
 18717           int y1 = it.current_y;
 18718           int vpos;
 18719 
 18720           /* A before-string that includes newlines and is displayed
 18721              on the last visible screen line could fail us under
 18722              scroll-conservatively > 100, because we will be unable to
 18723              position the cursor on that last visible line.  Try to
 18724              recover by finding the first screen line that has some
 18725              glyphs coming from the buffer text.  */
 18726           do {
 18727             skip = move_it_in_display_line_to (&it, ZV, -1, MOVE_TO_POS);
 18728             if (skip != MOVE_NEWLINE_OR_CR
 18729                 || IT_CHARPOS (it) != PT
 18730                 || it.method == GET_FROM_BUFFER)
 18731               break;
 18732             vpos = it.vpos;
 18733             move_it_to (&it, -1, -1, -1, vpos + 1, MOVE_TO_VPOS);
 18734           } while (it.vpos > vpos);
 18735 
 18736           dy = it.current_y - y1;
 18737 
 18738           if (dy > scroll_max)
 18739             return SCROLLING_FAILED;
 18740 
 18741           if (dy > 0)
 18742             scroll_down_p = true;
 18743         }
 18744     }
 18745 
 18746   if (scroll_down_p)
 18747     {
 18748       /* Point is in or below the bottom scroll margin, so move the
 18749          window start down.  If scrolling conservatively, move it just
 18750          enough down to make point visible.  If scroll_step is set,
 18751          move it down by scroll_step.  */
 18752       if (arg_scroll_conservatively)
 18753         amount_to_scroll
 18754           = min (max (dy, frame_line_height),
 18755                  frame_line_height * arg_scroll_conservatively);
 18756       else if (scroll_step || temp_scroll_step)
 18757         amount_to_scroll = scroll_max;
 18758       else
 18759         {
 18760           aggressive = BVAR (current_buffer, scroll_up_aggressively);
 18761           height = WINDOW_BOX_TEXT_HEIGHT (w);
 18762           if (NUMBERP (aggressive))
 18763             {
 18764               double float_amount = XFLOATINT (aggressive) * height;
 18765               int aggressive_scroll = float_amount;
 18766               if (aggressive_scroll == 0 && float_amount > 0)
 18767                 aggressive_scroll = 1;
 18768               /* Don't let point enter the scroll margin near top of
 18769                  the window.  This could happen if the value of
 18770                  scroll_up_aggressively is too large and there are
 18771                  non-zero margins, because scroll_up_aggressively
 18772                  means put point that fraction of window height
 18773                  _from_the_bottom_margin_.  */
 18774               if (aggressive_scroll + 2 * this_scroll_margin > height)
 18775                 aggressive_scroll = height - 2 * this_scroll_margin;
 18776               amount_to_scroll = dy + aggressive_scroll;
 18777             }
 18778         }
 18779 
 18780       if (amount_to_scroll <= 0)
 18781         return SCROLLING_FAILED;
 18782 
 18783       start_display (&it, w, startp);
 18784       if (arg_scroll_conservatively <= scroll_limit)
 18785         move_it_vertically (&it, amount_to_scroll);
 18786       else
 18787         {
 18788           /* Extra precision for users who set scroll-conservatively
 18789              to a large number: make sure the amount we scroll
 18790              the window start is never less than amount_to_scroll,
 18791              which was computed as distance from window bottom to
 18792              point.  This matters when lines at window top and lines
 18793              below window bottom have different height.  */
 18794           struct it it1;
 18795           void *it1data = NULL;
 18796           /* We use a temporary it1 because line_bottom_y can modify
 18797              its argument, if it moves one line down; see there.  */
 18798           int start_y;
 18799 
 18800           SAVE_IT (it1, it, it1data);
 18801           start_y = line_bottom_y (&it1);
 18802           do {
 18803             RESTORE_IT (&it, &it, it1data);
 18804             move_it_by_lines (&it, 1);
 18805             SAVE_IT (it1, it, it1data);
 18806           } while (IT_CHARPOS (it) < ZV
 18807                    && line_bottom_y (&it1) - start_y < amount_to_scroll);
 18808           bidi_unshelve_cache (it1data, true);
 18809         }
 18810 
 18811       /* If STARTP is unchanged, move it down another screen line.  */
 18812       if (IT_CHARPOS (it) == CHARPOS (startp))
 18813         move_it_by_lines (&it, 1);
 18814       startp = it.current.pos;
 18815     }
 18816   else
 18817     {
 18818       struct text_pos scroll_margin_pos = startp;
 18819       int y_offset = 0;
 18820 
 18821       /* See if point is inside the scroll margin at the top of the
 18822          window.  */
 18823       if (this_scroll_margin)
 18824         {
 18825           int y_start;
 18826 
 18827           start_display (&it, w, startp);
 18828           y_start = it.current_y;
 18829           move_it_vertically (&it, this_scroll_margin);
 18830           scroll_margin_pos = it.current.pos;
 18831           /* If we didn't move enough before hitting ZV, request
 18832              additional amount of scroll, to move point out of the
 18833              scroll margin.  */
 18834           if (IT_CHARPOS (it) == ZV
 18835               && it.current_y - y_start < this_scroll_margin)
 18836             y_offset = this_scroll_margin - (it.current_y - y_start);
 18837         }
 18838 
 18839       if (PT < CHARPOS (scroll_margin_pos))
 18840         {
 18841           /* Point is in the scroll margin at the top of the window or
 18842              above what is displayed in the window.  */
 18843           int y0, y_to_move;
 18844 
 18845           /* Compute the vertical distance from PT to the scroll
 18846              margin position.  Move as far as scroll_max allows, or
 18847              one screenful, or 10 screen lines, whichever is largest.
 18848              Give up if distance is greater than scroll_max or if we
 18849              didn't reach the scroll margin position.  */
 18850           SET_TEXT_POS (pos, PT, PT_BYTE);
 18851           start_display (&it, w, pos);
 18852           y0 = it.current_y;
 18853           y_to_move = max (it.last_visible_y,
 18854                            max (scroll_max, 10 * frame_line_height));
 18855           move_it_to (&it, CHARPOS (scroll_margin_pos), 0,
 18856                       y_to_move, -1,
 18857                       MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
 18858           dy = it.current_y - y0;
 18859           if (dy > scroll_max
 18860               || IT_CHARPOS (it) < CHARPOS (scroll_margin_pos))
 18861             return SCROLLING_FAILED;
 18862 
 18863           /* Additional scroll for when ZV was too close to point.  */
 18864           dy += y_offset;
 18865 
 18866           /* Compute new window start.  */
 18867           start_display (&it, w, startp);
 18868 
 18869           if (arg_scroll_conservatively)
 18870             amount_to_scroll
 18871               = min (max (dy, frame_line_height),
 18872                      frame_line_height * arg_scroll_conservatively);
 18873           else if (scroll_step || temp_scroll_step)
 18874             amount_to_scroll = scroll_max;
 18875           else
 18876             {
 18877               aggressive = BVAR (current_buffer, scroll_down_aggressively);
 18878               height = WINDOW_BOX_TEXT_HEIGHT (w);
 18879               if (NUMBERP (aggressive))
 18880                 {
 18881                   double float_amount = XFLOATINT (aggressive) * height;
 18882                   int aggressive_scroll = float_amount;
 18883                   if (aggressive_scroll == 0 && float_amount > 0)
 18884                     aggressive_scroll = 1;
 18885                   /* Don't let point enter the scroll margin near
 18886                      bottom of the window, if the value of
 18887                      scroll_down_aggressively happens to be too
 18888                      large.  */
 18889                   if (aggressive_scroll + 2 * this_scroll_margin > height)
 18890                     aggressive_scroll = height - 2 * this_scroll_margin;
 18891                   amount_to_scroll = dy + aggressive_scroll;
 18892                 }
 18893             }
 18894 
 18895           if (amount_to_scroll <= 0)
 18896             return SCROLLING_FAILED;
 18897 
 18898           move_it_vertically_backward (&it, amount_to_scroll);
 18899           startp = it.current.pos;
 18900         }
 18901     }
 18902 
 18903   /* Run window scroll functions.  */
 18904   startp = run_window_scroll_functions (window, startp);
 18905 
 18906   /* Display the window.  Give up if new fonts are loaded, or if point
 18907      doesn't appear.  */
 18908   if (!try_window (window, startp, 0))
 18909     rc = SCROLLING_NEED_LARGER_MATRICES;
 18910   else if (w->cursor.vpos < 0)
 18911     {
 18912       clear_glyph_matrix (w->desired_matrix);
 18913       rc = SCROLLING_FAILED;
 18914     }
 18915   else
 18916     {
 18917       /* Maybe forget recorded base line for line number display.  */
 18918       if (!just_this_one_p
 18919           || current_buffer->clip_changed
 18920           || BEG_UNCHANGED < CHARPOS (startp))
 18921         w->base_line_number = 0;
 18922 
 18923       /* If cursor ends up on a partially visible line,
 18924          treat that as being off the bottom of the screen.  */
 18925       if (! cursor_row_fully_visible_p (w, extra_scroll_margin_lines <= 1,
 18926                                         false, false)
 18927           /* It's possible that the cursor is on the first line of the
 18928              buffer, which is partially obscured due to a vscroll
 18929              (Bug#7537).  In that case, avoid looping forever. */
 18930           && extra_scroll_margin_lines < w->desired_matrix->nrows - 1)
 18931         {
 18932           clear_glyph_matrix (w->desired_matrix);
 18933           ++extra_scroll_margin_lines;
 18934           goto too_near_end;
 18935         }
 18936       rc = SCROLLING_SUCCESS;
 18937     }
 18938 
 18939   return rc;
 18940 }
 18941 
 18942 
 18943 /* Compute a suitable window start for window W if display of W starts
 18944    on a continuation line.  Value is true if a new window start
 18945    was computed.
 18946 
 18947    The new window start will be computed, based on W's width, starting
 18948    from the start of the continued line.  It is the start of the
 18949    screen line with the minimum distance from the old start W->start,
 18950    which is still before point (otherwise point will definitely not
 18951    be visible in the window).  */
 18952 
 18953 static bool
 18954 compute_window_start_on_continuation_line (struct window *w)
 18955 {
 18956   struct text_pos pos, start_pos, pos_before_pt;
 18957   bool window_start_changed_p = false;
 18958 
 18959   SET_TEXT_POS_FROM_MARKER (start_pos, w->start);
 18960 
 18961   /* If window start is on a continuation line...  Window start may be
 18962      < BEGV in case there's invisible text at the start of the
 18963      buffer (M-x rmail, for example).  */
 18964   if (CHARPOS (start_pos) > BEGV
 18965       && FETCH_BYTE (BYTEPOS (start_pos) - 1) != '\n')
 18966     {
 18967       struct it it;
 18968       struct glyph_row *row;
 18969 
 18970       /* Handle the case that the window start is out of range.  */
 18971       if (CHARPOS (start_pos) < BEGV)
 18972         SET_TEXT_POS (start_pos, BEGV, BEGV_BYTE);
 18973       else if (CHARPOS (start_pos) > ZV)
 18974         SET_TEXT_POS (start_pos, ZV, ZV_BYTE);
 18975 
 18976       /* Find the start of the continued line.  This should be fast
 18977          because find_newline is fast (newline cache).  */
 18978       row = w->desired_matrix->rows + window_wants_tab_line (w)
 18979                                     + window_wants_header_line (w);
 18980       init_iterator (&it, w, CHARPOS (start_pos), BYTEPOS (start_pos),
 18981                      row, DEFAULT_FACE_ID);
 18982       reseat_at_previous_visible_line_start (&it);
 18983 
 18984       /* Give up (by not using the code in the block below) and say it
 18985          takes too much time to compute a new window start, if the
 18986          line start is "too far" away from the window start.  Also,
 18987          give up if the line start is after point, as in that case
 18988          point will not be visible with any window start we
 18989          compute.  */
 18990       if (IT_CHARPOS (it) <= PT
 18991           && (CHARPOS (start_pos) - IT_CHARPOS (it)
 18992               /* PXW: Do we need upper bounds here?  */
 18993               < WINDOW_TOTAL_LINES (w) * WINDOW_TOTAL_COLS (w)))
 18994         {
 18995           int min_distance, distance;
 18996 
 18997           /* Move forward by display lines to find the new window
 18998              start.  If window width was enlarged, the new start can
 18999              be expected to be > the old start.  If window width was
 19000              decreased, the new window start will be < the old start.
 19001              So, we're looking for the display line start with the
 19002              minimum distance from the old window start.  */
 19003           pos_before_pt = pos = it.current.pos;
 19004           min_distance = DISP_INFINITY;
 19005           while ((distance = eabs (CHARPOS (start_pos) - IT_CHARPOS (it))),
 19006                  distance < min_distance)
 19007             {
 19008               min_distance = distance;
 19009               if (CHARPOS (pos) <= PT)
 19010                 pos_before_pt = pos;
 19011               pos = it.current.pos;
 19012               if (it.line_wrap == WORD_WRAP)
 19013                 {
 19014                   /* Under WORD_WRAP, move_it_by_lines is likely to
 19015                      overshoot and stop not at the first, but the
 19016                      second character from the left margin.  So in
 19017                      that case, we need a more tight control on the X
 19018                      coordinate of the iterator than move_it_by_lines
 19019                      promises in its contract.  The method is to first
 19020                      go to the last (rightmost) visible character of a
 19021                      line, then move to the leftmost character on the
 19022                      next line in a separate call.  */
 19023                   move_it_to (&it, ZV, it.last_visible_x, it.current_y, -1,
 19024                               MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
 19025                   move_it_to (&it, ZV, 0,
 19026                               it.current_y + it.max_ascent + it.max_descent, -1,
 19027                               MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
 19028                 }
 19029               else
 19030                 move_it_by_lines (&it, 1);
 19031             }
 19032 
 19033           /* It makes very little sense to make the new window start
 19034              after point, as point won't be visible.  If that's what
 19035              the loop above finds, fall back on the candidate before
 19036              or at point that is closest to the old window start.  */
 19037           if (CHARPOS (pos) > PT)
 19038             pos = pos_before_pt;
 19039 
 19040           /* Set the window start there.  */
 19041           SET_MARKER_FROM_TEXT_POS (w->start, pos);
 19042           window_start_changed_p = true;
 19043         }
 19044     }
 19045 
 19046   return window_start_changed_p;
 19047 }
 19048 
 19049 
 19050 /* Try cursor movement in case text has not changed in window WINDOW,
 19051    with window start STARTP.  Value is
 19052 
 19053    CURSOR_MOVEMENT_SUCCESS if successful
 19054 
 19055    CURSOR_MOVEMENT_CANNOT_BE_USED if this method cannot be used
 19056 
 19057    CURSOR_MOVEMENT_MUST_SCROLL if we know we have to scroll the
 19058    display.  *SCROLL_STEP is set to true, under certain circumstances, if
 19059    we want to scroll as if scroll-step were set to 1.  See the code.
 19060 
 19061    CURSOR_MOVEMENT_NEED_LARGER_MATRICES if we need larger matrices, in
 19062    which case we have to abort this redisplay, and adjust matrices
 19063    first.  */
 19064 
 19065 enum
 19066 {
 19067   CURSOR_MOVEMENT_SUCCESS,
 19068   CURSOR_MOVEMENT_CANNOT_BE_USED,
 19069   CURSOR_MOVEMENT_MUST_SCROLL,
 19070   CURSOR_MOVEMENT_NEED_LARGER_MATRICES
 19071 };
 19072 
 19073 static int
 19074 try_cursor_movement (Lisp_Object window, struct text_pos startp,
 19075                      bool *scroll_step)
 19076 {
 19077   struct window *w = XWINDOW (window);
 19078   struct frame *f = XFRAME (w->frame);
 19079   int rc = CURSOR_MOVEMENT_CANNOT_BE_USED;
 19080 
 19081 #ifdef GLYPH_DEBUG
 19082   if (inhibit_try_cursor_movement)
 19083     return rc;
 19084 #endif
 19085 
 19086   /* Previously, there was a check for Lisp integer in the
 19087      if-statement below. Now, this field is converted to
 19088      ptrdiff_t, thus zero means invalid position in a buffer.  */
 19089   eassert (w->last_point > 0);
 19090   /* Likewise there was a check whether window_end_vpos is nil or larger
 19091      than the window.  Now window_end_vpos is int and so never nil, but
 19092      let's leave eassert to check whether it fits in the window.  */
 19093   eassert (!w->window_end_valid
 19094            || w->window_end_vpos < w->current_matrix->nrows);
 19095 
 19096   /* Handle case where text has not changed, only point, and it has
 19097      not moved off the frame.  */
 19098   if (/* Point may be in this window.  */
 19099       PT >= CHARPOS (startp)
 19100       /* Selective display hasn't changed.  */
 19101       && !current_buffer->clip_changed
 19102       /* Function force-mode-line-update is used to force a thorough
 19103          redisplay.  It sets either windows_or_buffers_changed or
 19104          update_mode_lines.  So don't take a shortcut here for these
 19105          cases.  */
 19106       && !update_mode_lines
 19107       && !windows_or_buffers_changed
 19108       && !f->cursor_type_changed
 19109       && NILP (Vshow_trailing_whitespace)
 19110       /* When display-line-numbers is in relative mode, moving point
 19111          requires to redraw the entire window.  */
 19112       && !EQ (Vdisplay_line_numbers, Qrelative)
 19113       && !EQ (Vdisplay_line_numbers, Qvisual)
 19114       /* When the current line number should be displayed in a
 19115          distinct face, moving point cannot be handled in optimized
 19116          way as below.  */
 19117       && !(!NILP (Vdisplay_line_numbers)
 19118            && NILP (Finternal_lisp_face_equal_p (Qline_number,
 19119                                                  Qline_number_current_line,
 19120                                                  w->frame)))
 19121       /* This code is not used for mini-buffer for the sake of the case
 19122          of redisplaying to replace an echo area message; since in
 19123          that case the mini-buffer contents per se are usually
 19124          unchanged.  This code is of no real use in the mini-buffer
 19125          since the handling of this_line_start_pos, etc., in redisplay
 19126          handles the same cases.  */
 19127       && !EQ (window, minibuf_window)
 19128       /* When overlay arrow is shown in current buffer, point movement
 19129          is no longer "simple", as it typically causes the overlay
 19130          arrow to move as well.  */
 19131       && !overlay_arrow_in_current_buffer_p ())
 19132     {
 19133       int this_scroll_margin, top_scroll_margin;
 19134       struct glyph_row *row = NULL;
 19135 
 19136 #ifdef GLYPH_DEBUG
 19137       debug_method_add (w, "cursor movement");
 19138 #endif
 19139 
 19140       this_scroll_margin = window_scroll_margin (w, MARGIN_IN_PIXELS);
 19141 
 19142       top_scroll_margin = this_scroll_margin;
 19143       if (window_wants_tab_line (w))
 19144         top_scroll_margin += CURRENT_TAB_LINE_HEIGHT (w);
 19145       if (window_wants_header_line (w))
 19146         top_scroll_margin += CURRENT_HEADER_LINE_HEIGHT (w);
 19147 
 19148       /* Start with the row the cursor was displayed during the last
 19149          not paused redisplay.  Give up if that row is not valid.  */
 19150       if (w->last_cursor_vpos < 0
 19151           || w->last_cursor_vpos >= w->current_matrix->nrows)
 19152         rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19153       else
 19154         {
 19155           row = MATRIX_ROW (w->current_matrix, w->last_cursor_vpos);
 19156           /* Skip the tab-line and header-line rows, if any.  */
 19157           if (row->tab_line_p)
 19158             ++row;
 19159           if (row->mode_line_p)
 19160             ++row;
 19161           if (!row->enabled_p)
 19162             rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19163         }
 19164 
 19165       if (rc == CURSOR_MOVEMENT_CANNOT_BE_USED)
 19166         {
 19167           bool scroll_p = false, must_scroll = false;
 19168           int last_y = window_text_bottom_y (w) - this_scroll_margin;
 19169 
 19170           if (PT > w->last_point)
 19171             {
 19172               /* Point has moved forward.  */
 19173               while (MATRIX_ROW_END_CHARPOS (row) < PT
 19174                      && MATRIX_ROW_BOTTOM_Y (row) < last_y)
 19175                 {
 19176                   eassert (row->enabled_p);
 19177                   ++row;
 19178                 }
 19179 
 19180               /* If the end position of a row equals the start
 19181                  position of the next row, and PT is at that position,
 19182                  we would rather display cursor in the next line.  */
 19183               while (MATRIX_ROW_BOTTOM_Y (row) < last_y
 19184                      && MATRIX_ROW_END_CHARPOS (row) == PT
 19185                      && row < MATRIX_MODE_LINE_ROW (w->current_matrix)
 19186                      && MATRIX_ROW_START_CHARPOS (row+1) >= PT
 19187                      && !cursor_row_p (row))
 19188                 ++row;
 19189 
 19190               /* If within the scroll margin, scroll.  Note that
 19191                  MATRIX_ROW_BOTTOM_Y gives the pixel position at which
 19192                  the next line would be drawn, and that
 19193                  this_scroll_margin can be zero.  */
 19194               if (MATRIX_ROW_BOTTOM_Y (row) > last_y
 19195                   || PT > MATRIX_ROW_END_CHARPOS (row)
 19196                   /* Line is completely visible last line in window
 19197                      and PT is to be set in the next line.  */
 19198                   || (MATRIX_ROW_BOTTOM_Y (row) == last_y
 19199                       && PT == MATRIX_ROW_END_CHARPOS (row)
 19200                       && !row->ends_at_zv_p
 19201                       && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
 19202                 scroll_p = true;
 19203             }
 19204           else if (PT < w->last_point)
 19205             {
 19206               /* Cursor has to be moved backward.  Note that PT >=
 19207                  CHARPOS (startp) because of the outer if-statement.  */
 19208               struct glyph_row *row0 = row;
 19209 
 19210               while (!row->mode_line_p
 19211                      && (MATRIX_ROW_START_CHARPOS (row) > PT
 19212                          || (MATRIX_ROW_START_CHARPOS (row) == PT
 19213                              && (MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P (row)
 19214                                  || (/* STARTS_IN_MIDDLE_OF_STRING_P (row) */
 19215                                      row > w->current_matrix->rows
 19216                                      && (row-1)->ends_in_newline_from_string_p))))
 19217                      && (row->y > top_scroll_margin
 19218                          || CHARPOS (startp) == BEGV))
 19219                 {
 19220                   eassert (row->enabled_p);
 19221                   --row;
 19222                 }
 19223 
 19224               /* With bidi-reordered rows we can have buffer positions
 19225                  _decrease_ when going down by rows.  If we haven't
 19226                  found our row in the loop above, give it another try
 19227                  now going in the other direction from the original row.  */
 19228               if (!(MATRIX_ROW_START_CHARPOS (row) <= PT
 19229                     && PT <= MATRIX_ROW_END_CHARPOS (row))
 19230                   && row0->continued_p)
 19231                 {
 19232                   row = row0;
 19233                   while (MATRIX_ROW_START_CHARPOS (row) > PT
 19234                          && MATRIX_ROW_BOTTOM_Y (row) < last_y)
 19235                     {
 19236                       eassert (row->enabled_p);
 19237                       ++row;
 19238                     }
 19239                 }
 19240 
 19241               /* Consider the following case: Window starts at BEGV,
 19242                  there is invisible, intangible text at BEGV, so that
 19243                  display starts at some point START > BEGV.  It can
 19244                  happen that we are called with PT somewhere between
 19245                  BEGV and START.  Try to handle that case.  */
 19246               if (row < w->current_matrix->rows
 19247                   || row->mode_line_p)
 19248                 {
 19249                   row = w->current_matrix->rows;
 19250                   /* Skip the tab-line and header-line rows, if any.  */
 19251                   if (row->tab_line_p)
 19252                     ++row;
 19253                   if (row->mode_line_p)
 19254                     ++row;
 19255                 }
 19256 
 19257               /* Due to newlines in overlay strings, we may have to
 19258                  skip forward over overlay strings.  */
 19259               while (MATRIX_ROW_BOTTOM_Y (row) < last_y
 19260                      && MATRIX_ROW_END_CHARPOS (row) == PT
 19261                      && !cursor_row_p (row))
 19262                 ++row;
 19263 
 19264               /* If within the scroll margin, either the top one or
 19265                  the bottom one, scroll.  */
 19266               if ((row->y < top_scroll_margin
 19267                    && CHARPOS (startp) != BEGV)
 19268                   || MATRIX_ROW_BOTTOM_Y (row) > last_y
 19269                   || PT > MATRIX_ROW_END_CHARPOS (row)
 19270                   || (MATRIX_ROW_BOTTOM_Y (row) == last_y
 19271                       && PT == MATRIX_ROW_END_CHARPOS (row)
 19272                       && !row->ends_at_zv_p
 19273                       && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
 19274                 scroll_p = true;
 19275             }
 19276           else
 19277             {
 19278               /* Cursor did not move.  So don't scroll even if cursor line
 19279                  is partially visible, as it was so before.  */
 19280                  rc = CURSOR_MOVEMENT_SUCCESS;
 19281             }
 19282 
 19283           if ((PT < MATRIX_ROW_START_CHARPOS (row)
 19284                && (row == MATRIX_FIRST_TEXT_ROW (w->current_matrix)
 19285                    /* Don't give up if point is inside invisible text
 19286                       at the beginning of its glyph row.  */
 19287                    || (MATRIX_ROW_END_CHARPOS (row-1)
 19288                        == MATRIX_ROW_START_CHARPOS (row))))
 19289               || PT > MATRIX_ROW_END_CHARPOS (row))
 19290             {
 19291               /* if PT is not in the glyph row, give up.  */
 19292               rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19293               must_scroll = true;
 19294             }
 19295           else if (rc != CURSOR_MOVEMENT_SUCCESS
 19296                    && !NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering)))
 19297             {
 19298               struct glyph_row *row1;
 19299 
 19300               /* If rows are bidi-reordered and point moved, back up
 19301                  until we find a row that does not belong to a
 19302                  continuation line.  This is because we must consider
 19303                  all rows of a continued line as candidates for the
 19304                  new cursor positioning, since row start and end
 19305                  positions change non-linearly with vertical position
 19306                  in such rows.  */
 19307               /* FIXME: Revisit this when glyph ``spilling'' in
 19308                  continuation lines' rows is implemented for
 19309                  bidi-reordered rows.  */
 19310               for (row1 = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 19311                    MATRIX_ROW_CONTINUATION_LINE_P (row);
 19312                    --row)
 19313                 {
 19314                   /* If we hit the beginning of the displayed portion
 19315                      without finding the first row of a continued
 19316                      line, give up.  */
 19317                   if (row <= row1)
 19318                     {
 19319                       rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19320                       break;
 19321                     }
 19322                   eassert (row->enabled_p);
 19323                 }
 19324             }
 19325           if (must_scroll)
 19326             ;
 19327           else if (rc != CURSOR_MOVEMENT_SUCCESS
 19328               && MATRIX_ROW_PARTIALLY_VISIBLE_P (w, row)
 19329               /* Make sure this isn't a header line nor a tab-line by
 19330                  any chance, since then MATRIX_ROW_PARTIALLY_VISIBLE_P
 19331                  might yield true.  */
 19332               && !row->mode_line_p
 19333               && !cursor_row_fully_visible_p (w, true, true, true))
 19334             {
 19335               if (PT == MATRIX_ROW_END_CHARPOS (row)
 19336                   && !row->ends_at_zv_p
 19337                   && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))
 19338                 rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19339               else if (row->height > window_box_height (w))
 19340                 {
 19341                   /* If we end up in a partially visible line, let's
 19342                      make it fully visible, except when it's taller
 19343                      than the window, in which case we can't do much
 19344                      about it.  */
 19345                   *scroll_step = true;
 19346                   rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19347                 }
 19348               else
 19349                 {
 19350                   set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
 19351                   if (!cursor_row_fully_visible_p (w, false, true, false))
 19352                     rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19353                   else
 19354                     rc = CURSOR_MOVEMENT_SUCCESS;
 19355                 }
 19356             }
 19357           else if (scroll_p)
 19358             rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19359           else if (rc != CURSOR_MOVEMENT_SUCCESS
 19360                    && !NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering)))
 19361             {
 19362               /* With bidi-reordered rows, there could be more than
 19363                  one candidate row whose start and end positions
 19364                  occlude point.  We need to let set_cursor_from_row
 19365                  find the best candidate.  */
 19366               /* FIXME: Revisit this when glyph ``spilling'' in
 19367                  continuation lines' rows is implemented for
 19368                  bidi-reordered rows.  */
 19369               bool rv = false;
 19370               bool pt_invis = false;
 19371               Lisp_Object val = get_char_property_and_overlay (make_fixnum (PT),
 19372                                                                Qinvisible,
 19373                                                                Qnil, NULL);
 19374 
 19375               if (TEXT_PROP_MEANS_INVISIBLE (val) != 0)
 19376                 pt_invis = true;
 19377 
 19378               do
 19379                 {
 19380                   bool at_zv_p = false, exact_match_p = false;
 19381 
 19382                   /* If point is in invisible text, we cannot assume
 19383                      it must be after row's start position, since the
 19384                      row could have invisible text at its beginning
 19385                      where point is located.  */
 19386                   if ((pt_invis || MATRIX_ROW_START_CHARPOS (row) <= PT)
 19387                       && PT <= MATRIX_ROW_END_CHARPOS (row)
 19388                       && cursor_row_p (row))
 19389                     rv |= set_cursor_from_row (w, row, w->current_matrix,
 19390                                                0, 0, 0, 0);
 19391                   /* As soon as we've found the exact match for point,
 19392                      or the first suitable row whose ends_at_zv_p flag
 19393                      is set, we are done.  */
 19394                   if (rv)
 19395                     {
 19396                       at_zv_p = MATRIX_ROW (w->current_matrix,
 19397                                             w->cursor.vpos)->ends_at_zv_p;
 19398                       if (!at_zv_p
 19399                           && w->cursor.hpos >= 0
 19400                           && w->cursor.hpos < MATRIX_ROW_USED (w->current_matrix,
 19401                                                                w->cursor.vpos))
 19402                         {
 19403                           struct glyph_row *candidate =
 19404                             MATRIX_ROW (w->current_matrix, w->cursor.vpos);
 19405                           struct glyph *g =
 19406                             candidate->glyphs[TEXT_AREA] + w->cursor.hpos;
 19407                           ptrdiff_t endpos = MATRIX_ROW_END_CHARPOS (candidate);
 19408 
 19409                           exact_match_p =
 19410                             (BUFFERP (g->object) && g->charpos == PT)
 19411                             || (NILP (g->object)
 19412                                 && (g->charpos == PT
 19413                                     || (g->charpos == 0 && endpos - 1 == PT)));
 19414                           /* Perhaps the point position is inside
 19415                              invisible text?  In that case, we trust
 19416                              'set_cursor_from_row' to do its job and
 19417                              find the best position for the cursor.  */
 19418                           if (!exact_match_p && pt_invis)
 19419                             exact_match_p = true;
 19420                         }
 19421                       if (at_zv_p || exact_match_p)
 19422                         {
 19423                           rc = CURSOR_MOVEMENT_SUCCESS;
 19424                           break;
 19425                         }
 19426                     }
 19427                   if (MATRIX_ROW_BOTTOM_Y (row) == last_y)
 19428                     break;
 19429                   ++row;
 19430                 }
 19431               while (((MATRIX_ROW_CONTINUATION_LINE_P (row)
 19432                        || row->continued_p)
 19433                       && MATRIX_ROW_BOTTOM_Y (row) <= last_y)
 19434                      || (MATRIX_ROW_START_CHARPOS (row) == PT
 19435                          && MATRIX_ROW_BOTTOM_Y (row) < last_y));
 19436               /* If we didn't find any candidate rows, or exited the
 19437                  loop before all the candidates were examined, signal
 19438                  to the caller that this method failed.  */
 19439               if (rc != CURSOR_MOVEMENT_SUCCESS
 19440                   && !(rv
 19441                        && !MATRIX_ROW_CONTINUATION_LINE_P (row)
 19442                        && !row->continued_p))
 19443                 rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19444               else if (rv)
 19445                 rc = CURSOR_MOVEMENT_SUCCESS;
 19446             }
 19447           else
 19448             {
 19449               do
 19450                 {
 19451                   if (set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0))
 19452                     {
 19453                       rc = CURSOR_MOVEMENT_SUCCESS;
 19454                       break;
 19455                     }
 19456                   ++row;
 19457                 }
 19458               while (MATRIX_ROW_BOTTOM_Y (row) < last_y
 19459                      && MATRIX_ROW_START_CHARPOS (row) == PT
 19460                      && cursor_row_p (row));
 19461             }
 19462         }
 19463     }
 19464 
 19465   return rc;
 19466 }
 19467 
 19468 
 19469 void
 19470 set_vertical_scroll_bar (struct window *w)
 19471 {
 19472   ptrdiff_t start, end, whole;
 19473 
 19474   /* Calculate the start and end positions for the current window.
 19475      At some point, it would be nice to choose between scrollbars
 19476      which reflect the whole buffer size, with special markers
 19477      indicating narrowing, and scrollbars which reflect only the
 19478      visible region.
 19479 
 19480      Note that mini-buffers sometimes aren't displaying any text.  */
 19481   if (!MINI_WINDOW_P (w)
 19482       || (w == XWINDOW (minibuf_window)
 19483           && NILP (echo_area_buffer[0])))
 19484     {
 19485       struct buffer *buf = XBUFFER (w->contents);
 19486 
 19487       whole = BUF_ZV (buf) - BUF_BEGV (buf);
 19488       start = marker_position (w->start) - BUF_BEGV (buf);
 19489       end = BUF_Z (buf) - w->window_end_pos - BUF_BEGV (buf);
 19490 
 19491       /* If w->window_end_pos cannot be trusted, recompute it "the
 19492          hard way".  But don't bother to be too accurate when
 19493          long-line shortcuts are in effect.  */
 19494       if (!w->window_end_valid && !buf->long_line_optimizations_p)
 19495         {
 19496           struct it it;
 19497           struct text_pos start_pos;
 19498           struct buffer *obuf = current_buffer;
 19499           /* When we display the scroll bar of a mini-window,
 19500              current_buffer is not guaranteed to be the mini-window's
 19501              buffer, see the beginning of redisplay_window.  */
 19502           set_buffer_internal_1 (XBUFFER (w->contents));
 19503           SET_TEXT_POS_FROM_MARKER (start_pos, w->start);
 19504           start_display (&it, w, start_pos);
 19505           move_it_to (&it, -1, it.last_visible_x, window_box_height (w), -1,
 19506                       MOVE_TO_X | MOVE_TO_Y);
 19507           end -= (BUF_Z (buf) - IT_CHARPOS (it)) - w->window_end_pos;
 19508           set_buffer_internal_1 (obuf);
 19509         }
 19510 
 19511       if (end < start)
 19512         end = start;
 19513       if (whole < (end - start))
 19514         whole = end - start;
 19515     }
 19516   else
 19517     start = end = whole = 0;
 19518 
 19519   /* Indicate what this scroll bar ought to be displaying now.  */
 19520   if (FRAME_TERMINAL (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
 19521     (*FRAME_TERMINAL (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
 19522       (w, end - start, whole, start);
 19523 }
 19524 
 19525 
 19526 void
 19527 set_horizontal_scroll_bar (struct window *w)
 19528 {
 19529   int start, end, whole, portion;
 19530 
 19531   if (!MINI_WINDOW_P (w) || EQ (w->horizontal_scroll_bar_type, Qbottom))
 19532     {
 19533       struct buffer *b = XBUFFER (w->contents);
 19534       struct buffer *old_buffer = NULL;
 19535       struct it it;
 19536       struct text_pos startp;
 19537 
 19538       if (b != current_buffer)
 19539         {
 19540           old_buffer = current_buffer;
 19541           set_buffer_internal (b);
 19542         }
 19543 
 19544       SET_TEXT_POS_FROM_MARKER (startp, w->start);
 19545       start_display (&it, w, startp);
 19546       it.last_visible_x = INT_MAX;
 19547       whole = move_it_to (&it, -1, INT_MAX, window_box_height (w), -1,
 19548                           MOVE_TO_X | MOVE_TO_Y);
 19549       /* whole = move_it_to (&it, w->window_end_pos, INT_MAX,
 19550                           window_box_height (w), -1,
 19551                           MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y); */
 19552 
 19553       start = w->hscroll * FRAME_COLUMN_WIDTH (WINDOW_XFRAME (w));
 19554       end = start + window_box_width (w, TEXT_AREA);
 19555       portion = end - start;
 19556       /* After enlarging a horizontally scrolled window such that it
 19557          gets at least as wide as the text it contains, make sure that
 19558          the thumb doesn't fill the entire scroll bar so we can still
 19559          drag it back to see the entire text.  */
 19560       whole = max (whole, end);
 19561 
 19562       if (it.bidi_p)
 19563         {
 19564           Lisp_Object pdir;
 19565 
 19566           pdir = Fcurrent_bidi_paragraph_direction (Qnil);
 19567           if (EQ (pdir, Qright_to_left))
 19568             {
 19569               start = whole - end;
 19570               end = start + portion;
 19571             }
 19572         }
 19573 
 19574       if (old_buffer)
 19575         set_buffer_internal (old_buffer);
 19576     }
 19577   else
 19578     start = end = whole = portion = 0;
 19579 
 19580   w->hscroll_whole = whole;
 19581 
 19582   /* Indicate what this scroll bar ought to be displaying now.  */
 19583   if (FRAME_TERMINAL (XFRAME (w->frame))->set_horizontal_scroll_bar_hook)
 19584     (*FRAME_TERMINAL (XFRAME (w->frame))->set_horizontal_scroll_bar_hook)
 19585       (w, portion, whole, start);
 19586 }
 19587 
 19588 /* Subroutine of redisplay_window, to determine whether a window-start
 19589    point STARTP of WINDOW should be rejected.  */
 19590 static bool
 19591 window_start_acceptable_p (Lisp_Object window, ptrdiff_t startp)
 19592 {
 19593   if (!make_window_start_visible)
 19594     return true;
 19595 
 19596   struct window *w = XWINDOW (window);
 19597   struct frame *f = XFRAME (w->frame);
 19598   Lisp_Object startpos = make_fixnum (startp);
 19599   Lisp_Object invprop, disp_spec;
 19600   struct text_pos ignored;
 19601 
 19602   /* Is STARTP in invisible text?  */
 19603   if ((invprop = Fget_char_property (startpos, Qinvisible, window)),
 19604       TEXT_PROP_MEANS_INVISIBLE (invprop) != 0)
 19605     return false;
 19606 
 19607   /* Is STARTP covered by a replacing 'display' property?  */
 19608   if (!NILP (disp_spec = Fget_char_property (startpos, Qdisplay, window))
 19609       && handle_display_spec (NULL, disp_spec, Qnil, Qnil, &ignored, startp,
 19610                               FRAME_WINDOW_P (f)) > 0)
 19611     return false;
 19612 
 19613   return true;
 19614 }
 19615 
 19616 DEFUN ("long-line-optimizations-p", Flong_line_optimizations_p, Slong_line_optimizations_p,
 19617        0, 0, 0,
 19618        doc: /* Return non-nil if long-line optimizations are in effect in current buffer.
 19619 See `long-line-threshold' and `large-hscroll-threshold' for what these
 19620 optimizations mean and when they are in effect.  */)
 19621   (void)
 19622 {
 19623   return current_buffer->long_line_optimizations_p ? Qt : Qnil;
 19624 }
 19625 
 19626 /* Redisplay leaf window WINDOW.  JUST_THIS_ONE_P means only
 19627    selected_window is redisplayed.
 19628 
 19629    We can return without actually redisplaying the window if fonts has been
 19630    changed on window's frame.  In that case, redisplay_internal will retry.
 19631 
 19632    As one of the important parts of redisplaying a window, we need to
 19633    decide whether the previous window-start position (stored in the
 19634    window's w->start marker position) is still valid, and if it isn't,
 19635    recompute it.  Some details about that:
 19636 
 19637     . The previous window-start could be in a continuation line, in
 19638       which case we need to recompute it when the window width
 19639       changes.  See compute_window_start_on_continuation_line and its
 19640       call below.
 19641 
 19642     . The text that changed since last redisplay could include the
 19643       previous window-start position.  In that case, we try to salvage
 19644       what we can from the current glyph matrix by calling
 19645       try_scrolling, which see.
 19646 
 19647     . Some Emacs command could force us to use a specific window-start
 19648       position by setting the window's force_start flag, or gently
 19649       propose doing that by setting the window's optional_new_start
 19650       flag.  In these cases, we try using the specified start point if
 19651       that succeeds (i.e. the window desired matrix is successfully
 19652       recomputed, and point location is within the window).  In case
 19653       of optional_new_start, we first check if the specified start
 19654       position is feasible, i.e. if it will allow point to be
 19655       displayed in the window.  If using the specified start point
 19656       fails, e.g., if new fonts are needed to be loaded, we abort the
 19657       redisplay cycle and leave it up to the next cycle to figure out
 19658       things.
 19659 
 19660     . Note that the window's force_start flag is sometimes set by
 19661       redisplay itself, when it decides that the previous window start
 19662       point is fine and should be kept.  Search for "goto force_start"
 19663       below to see the details.  Like the values of window-start
 19664       specified outside of redisplay, these internally-deduced values
 19665       are tested for feasibility, and ignored if found to be
 19666       unfeasible.
 19667 
 19668     . Note that the function try_window, used to completely redisplay
 19669       a window, accepts the window's start point as its argument.
 19670       This is used several times in the redisplay code to control
 19671       where the window start will be, according to user options such
 19672       as scroll-conservatively, and also to ensure the screen line
 19673       showing point will be fully (as opposed to partially) visible on
 19674       display.  */
 19675 
 19676 static void
 19677 redisplay_window (Lisp_Object window, bool just_this_one_p)
 19678 {
 19679   struct window *w = XWINDOW (window);
 19680   struct frame *f = XFRAME (w->frame);
 19681   struct buffer *buffer = XBUFFER (w->contents);
 19682   struct buffer *old = current_buffer;
 19683   struct text_pos lpoint, opoint, startp;
 19684   bool update_mode_line;
 19685   int tem;
 19686   struct it it;
 19687   /* Record it now because it's overwritten.  */
 19688   bool current_matrix_up_to_date_p = false;
 19689   bool used_current_matrix_p = false;
 19690   /* This is less strict than current_matrix_up_to_date_p.
 19691      It indicates that the buffer contents and narrowing are unchanged.  */
 19692   bool buffer_unchanged_p = false;
 19693   bool temp_scroll_step = false;
 19694   specpdl_ref count = SPECPDL_INDEX ();
 19695   int rc;
 19696   int centering_position = -1;
 19697   bool last_line_misfit = false;
 19698   ptrdiff_t beg_unchanged, end_unchanged;
 19699   int frame_line_height, margin;
 19700   bool use_desired_matrix;
 19701   void *itdata = NULL;
 19702 
 19703   SET_TEXT_POS (lpoint, PT, PT_BYTE);
 19704   opoint = lpoint;
 19705 
 19706 #ifdef GLYPH_DEBUG
 19707   *w->desired_matrix->method = 0;
 19708 #endif
 19709 
 19710   if (!just_this_one_p && needs_no_redisplay (w))
 19711     return;
 19712 
 19713   /* Make sure that both W's markers are valid.  */
 19714   eassert (XMARKER (w->start)->buffer == buffer);
 19715   eassert (XMARKER (w->pointm)->buffer == buffer);
 19716 
 19717   reconsider_clip_changes (w);
 19718   frame_line_height = default_line_pixel_height (w);
 19719   margin = window_scroll_margin (w, MARGIN_IN_LINES);
 19720 
 19721 
 19722   /* Has the mode line to be updated?  */
 19723   update_mode_line = (w->update_mode_line
 19724                       || update_mode_lines
 19725                       || buffer->clip_changed
 19726                       || buffer->prevent_redisplay_optimizations_p);
 19727 
 19728   if (!just_this_one_p)
 19729     /* If `just_this_one_p' is set, we apparently set must_be_updated_p more
 19730        cleverly elsewhere.  */
 19731     w->must_be_updated_p = true;
 19732 
 19733   if (MINI_WINDOW_P (w))
 19734     {
 19735       if (w == XWINDOW (echo_area_window)
 19736           && !NILP (echo_area_buffer[0]))
 19737         {
 19738           if (update_mode_line)
 19739             /* We may have to update a tty frame's menu bar or a
 19740                tool-bar.  Example `M-x C-h C-h C-g'.  */
 19741             goto finish_menu_bars;
 19742           else
 19743             /* We've already displayed the echo area glyphs in this window.  */
 19744             goto finish_scroll_bars;
 19745         }
 19746       else if ((w != XWINDOW (minibuf_window)
 19747                 || minibuf_level == 0)
 19748                /* When buffer is nonempty, redisplay window normally.  */
 19749                && BUF_Z (XBUFFER (w->contents)) == BUF_BEG (XBUFFER (w->contents))
 19750                /* Quail displays non-mini buffers in minibuffer window.
 19751                   In that case, redisplay the window normally.  */
 19752                && !NILP (Fmemq (w->contents, Vminibuffer_list)))
 19753         {
 19754           /* W is a mini-buffer window, but it's not active, so clear
 19755              it.  */
 19756           int yb = window_text_bottom_y (w);
 19757           struct glyph_row *row;
 19758           int y;
 19759 
 19760           for (y = 0, row = w->desired_matrix->rows;
 19761                y < yb;
 19762                y += row->height, ++row)
 19763             blank_row (w, row, y);
 19764           goto finish_scroll_bars;
 19765         }
 19766       else if (minibuf_level >= 1)
 19767         {
 19768           /* We could have a message produced by set-minibuffer-message
 19769              displayed in the mini-window as an overlay, so resize the
 19770              mini-window if needed.  */
 19771           resize_mini_window (w, false);
 19772         }
 19773 
 19774       clear_glyph_matrix (w->desired_matrix);
 19775     }
 19776 
 19777   /* Otherwise set up data on this window; select its buffer and point
 19778      value.  */
 19779   /* Really select the buffer, for the sake of buffer-local
 19780      variables.  */
 19781   set_buffer_internal_1 (XBUFFER (w->contents));
 19782 
 19783   current_matrix_up_to_date_p
 19784     = (w->window_end_valid
 19785        && !current_buffer->clip_changed
 19786        && !current_buffer->prevent_redisplay_optimizations_p
 19787        && !window_outdated (w)
 19788        && !composition_break_at_point
 19789        && !hscrolling_current_line_p (w));
 19790 
 19791   beg_unchanged = BEG_UNCHANGED;
 19792   end_unchanged = END_UNCHANGED;
 19793 
 19794   SET_TEXT_POS (opoint, PT, PT_BYTE);
 19795 
 19796   specbind (Qinhibit_point_motion_hooks, Qt);
 19797 
 19798   buffer_unchanged_p
 19799     = (w->window_end_valid
 19800        && !current_buffer->clip_changed
 19801        && !window_outdated (w));
 19802 
 19803   /* When windows_or_buffers_changed is non-zero, we can't rely
 19804      on the window end being valid, so set it to zero there.  */
 19805   if (windows_or_buffers_changed)
 19806     {
 19807       /* If window starts on a continuation line, maybe adjust the
 19808          window start in case the window's width changed.  */
 19809       if (XMARKER (w->start)->buffer == current_buffer)
 19810         compute_window_start_on_continuation_line (w);
 19811 
 19812       w->window_end_valid = false;
 19813       /* If so, we also can't rely on current matrix
 19814          and should not fool try_cursor_movement below.  */
 19815       current_matrix_up_to_date_p = false;
 19816     }
 19817 
 19818   /* Some sanity checks.  */
 19819   CHECK_WINDOW_END (w);
 19820   if (Z == Z_BYTE && CHARPOS (opoint) != BYTEPOS (opoint))
 19821     emacs_abort ();
 19822   if (BYTEPOS (opoint) < CHARPOS (opoint))
 19823     emacs_abort ();
 19824 
 19825   if (mode_line_update_needed (w))
 19826     update_mode_line = true;
 19827 
 19828   /* Point refers normally to the selected window.  For any other
 19829      window, set up appropriate value.  */
 19830   if (!EQ (window, selected_window))
 19831     {
 19832       ptrdiff_t new_pt = marker_position (w->pointm);
 19833       ptrdiff_t new_pt_byte = marker_byte_position (w->pointm);
 19834 
 19835       if (new_pt < BEGV)
 19836         {
 19837           new_pt = BEGV;
 19838           new_pt_byte = BEGV_BYTE;
 19839           set_marker_both (w->pointm, Qnil, BEGV, BEGV_BYTE);
 19840         }
 19841       else if (new_pt > (ZV - 1))
 19842         {
 19843           new_pt = ZV;
 19844           new_pt_byte = ZV_BYTE;
 19845           set_marker_both (w->pointm, Qnil, ZV, ZV_BYTE);
 19846         }
 19847 
 19848       /* We don't use SET_PT so that the point-motion hooks don't run.  */
 19849       TEMP_SET_PT_BOTH (new_pt, new_pt_byte);
 19850     }
 19851 
 19852   /* If any of the character widths specified in the display table
 19853      have changed, invalidate the width run cache.  It's true that
 19854      this may be a bit late to catch such changes, but the rest of
 19855      redisplay goes (non-fatally) haywire when the display table is
 19856      changed, so why should we worry about doing any better?  */
 19857   if (current_buffer->width_run_cache
 19858       || (current_buffer->base_buffer
 19859           && current_buffer->base_buffer->width_run_cache))
 19860     {
 19861       struct Lisp_Char_Table *disptab = buffer_display_table ();
 19862 
 19863       if (! disptab_matches_widthtab
 19864           (disptab, XVECTOR (BVAR (current_buffer, width_table))))
 19865         {
 19866           struct buffer *buf = current_buffer;
 19867 
 19868           if (buf->base_buffer)
 19869             buf = buf->base_buffer;
 19870           invalidate_region_cache (buf, buf->width_run_cache, BEG, Z);
 19871           recompute_width_table (current_buffer, disptab);
 19872         }
 19873     }
 19874 
 19875   /* Check whether the buffer to be displayed contains long lines.  */
 19876   if (!NILP (Vlong_line_threshold)
 19877       && !current_buffer->long_line_optimizations_p
 19878       && (CHARS_MODIFF - UNCHANGED_MODIFIED > 8
 19879           || current_buffer->clip_changed))
 19880     {
 19881       ptrdiff_t cur, next, found, max = 0, threshold;
 19882       threshold = XFIXNUM (Vlong_line_threshold);
 19883       for (cur = BEGV; cur < ZV; cur = next)
 19884         {
 19885           next = find_newline1 (cur, CHAR_TO_BYTE (cur), 0, -1, 1,
 19886                                 &found, NULL, true);
 19887           if (next - cur > max) max = next - cur;
 19888           if (!found || max > threshold) break;
 19889         }
 19890       if (max > threshold)
 19891         current_buffer->long_line_optimizations_p = true;
 19892     }
 19893 
 19894   /* If window-start is screwed up, choose a new one.  */
 19895   if (XMARKER (w->start)->buffer != current_buffer)
 19896     goto recenter;
 19897 
 19898   SET_TEXT_POS_FROM_MARKER (startp, w->start);
 19899 
 19900   /* If someone specified a new starting point but did not insist,
 19901      check whether it can be used.  */
 19902   if ((w->optional_new_start || window_frozen_p (w))
 19903       && CHARPOS (startp) >= BEGV
 19904       && CHARPOS (startp) <= ZV)
 19905     {
 19906       ptrdiff_t it_charpos;
 19907 
 19908       w->optional_new_start = false;
 19909       if (!w->force_start)
 19910         {
 19911           start_display (&it, w, startp);
 19912           move_it_to (&it, PT, 0, it.last_visible_y, -1,
 19913                       MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
 19914           /* Record IT's position now, since line_bottom_y might
 19915              change that.  */
 19916           it_charpos = IT_CHARPOS (it);
 19917           /* Make sure we set the force_start flag only if the cursor
 19918              row will be fully visible.  Otherwise, the code under
 19919              force_start label below will try to move point back into
 19920              view, which is not what the code which sets
 19921              optional_new_start wants.  */
 19922           if (it.current_y == 0 || line_bottom_y (&it) < it.last_visible_y)
 19923             {
 19924               if (it_charpos == PT)
 19925                 w->force_start = true;
 19926               /* IT may overshoot PT if text at PT is invisible.  */
 19927               else if (it_charpos > PT && CHARPOS (startp) <= PT)
 19928                 w->force_start = true;
 19929 #ifdef GLYPH_DEBUG
 19930               if (w->force_start)
 19931                 {
 19932                   if (window_frozen_p (w))
 19933                     debug_method_add (w, "set force_start from frozen window start");
 19934                   else
 19935                     debug_method_add (w, "set force_start from optional_new_start");
 19936                 }
 19937 #endif
 19938             }
 19939         }
 19940     }
 19941 
 19942  force_start:
 19943 
 19944   /* Handle case where place to start displaying has been specified,
 19945      unless the specified location is outside the accessible range.  */
 19946   if (w->force_start)
 19947     {
 19948       /* We set this later on if we have to adjust point.  */
 19949       int new_vpos = -1;
 19950 
 19951       w->force_start = false;
 19952 
 19953       /* The vscroll should be preserved in this case, since
 19954          `pixel-scroll-precision-mode' must continue working normally
 19955          when a mini-window is resized.  (bug#55312) */
 19956       if (!w->preserve_vscroll_p || !window_frozen_p (w))
 19957         w->vscroll = 0;
 19958 
 19959       w->preserve_vscroll_p = false;
 19960       w->window_end_valid = false;
 19961 
 19962       /* Forget any recorded base line for line number display.  */
 19963       if (!buffer_unchanged_p)
 19964         w->base_line_number = 0;
 19965 
 19966       /* Redisplay the mode line.  Select the buffer properly for that.
 19967          Also, run the hook window-scroll-functions
 19968          because we have scrolled.  */
 19969       /* Note, we do this after clearing force_start because
 19970          if there's an error, it is better to forget about force_start
 19971          than to get into an infinite loop calling the hook functions
 19972          and having them get more errors.  */
 19973       if (!update_mode_line
 19974           || ! NILP (Vwindow_scroll_functions))
 19975         {
 19976           update_mode_line = true;
 19977           w->update_mode_line = true;
 19978           startp = run_window_scroll_functions (window, startp);
 19979         }
 19980 
 19981       if (CHARPOS (startp) < BEGV)
 19982         SET_TEXT_POS (startp, BEGV, BEGV_BYTE);
 19983       else if (CHARPOS (startp) > ZV)
 19984         SET_TEXT_POS (startp, ZV, ZV_BYTE);
 19985 
 19986       /* Reject the specified start location if it is invisible, and
 19987          the buffer wants it always visible.  */
 19988       if (!window_start_acceptable_p (window, CHARPOS (startp)))
 19989         goto ignore_start;
 19990 
 19991       /* Redisplay, then check if cursor has been set during the
 19992          redisplay.  Give up if new fonts were loaded.  */
 19993       /* We used to issue a CHECK_MARGINS argument to try_window here,
 19994          but this causes scrolling to fail when point begins inside
 19995          the scroll margin (bug#148) -- cyd  */
 19996       clear_glyph_matrix (w->desired_matrix);
 19997       if (!try_window (window, startp, 0))
 19998         {
 19999           w->force_start = true;
 20000           clear_glyph_matrix (w->desired_matrix);
 20001           goto need_larger_matrices;
 20002         }
 20003 
 20004       if (w->cursor.vpos < 0)
 20005         {
 20006           /* If point does not appear, try to move point so it does
 20007              appear.  The desired matrix has been built above, so we
 20008              can use it here.  First see if point is in invisible
 20009              text, and if so, move it to the first visible buffer
 20010              position past that.  */
 20011           struct glyph_row *r = NULL;
 20012           Lisp_Object invprop =
 20013             get_char_property_and_overlay (make_fixnum (PT), Qinvisible,
 20014                                            Qnil, NULL);
 20015 
 20016           if (TEXT_PROP_MEANS_INVISIBLE (invprop) != 0)
 20017             {
 20018               ptrdiff_t alt_pt;
 20019               Lisp_Object invprop_end =
 20020                 Fnext_single_char_property_change (make_fixnum (PT), Qinvisible,
 20021                                                    Qnil, Qnil);
 20022 
 20023               if (FIXNATP (invprop_end))
 20024                 alt_pt = XFIXNAT (invprop_end);
 20025               else
 20026                 alt_pt = ZV;
 20027               r = row_containing_pos (w, alt_pt, w->desired_matrix->rows,
 20028                                       NULL, 0);
 20029             }
 20030           if (r)
 20031             new_vpos = MATRIX_ROW_BOTTOM_Y (r);
 20032           else  /* Give up and just move to the middle of the window.  */
 20033             new_vpos = window_box_height (w) / 2;
 20034         }
 20035 
 20036       if (!cursor_row_fully_visible_p (w, false, false, false))
 20037         {
 20038           /* Point does appear, but on a line partly visible at end of window.
 20039              Move it back to a fully-visible line.  */
 20040           new_vpos = window_box_height (w);
 20041           /* But if window_box_height suggests a Y coordinate that is
 20042              not less than we already have, that line will clearly not
 20043              be fully visible, so give up and scroll the display.
 20044              This can happen when the default face uses a font whose
 20045              dimensions are different from the frame's default
 20046              font.  */
 20047           if (new_vpos >= w->cursor.y)
 20048             {
 20049               w->cursor.vpos = -1;
 20050               clear_glyph_matrix (w->desired_matrix);
 20051               goto try_to_scroll;
 20052             }
 20053         }
 20054       else if (w->cursor.vpos >= 0)
 20055         {
 20056           /* Some people insist on not letting point enter the scroll
 20057              margin, even though this part handles windows that didn't
 20058              scroll at all.  */
 20059           int pixel_margin = margin * frame_line_height;
 20060           bool tab_line = window_wants_tab_line (w);
 20061           bool header_line = window_wants_header_line (w);
 20062 
 20063           /* Note: We add an extra FRAME_LINE_HEIGHT, because the loop
 20064              below, which finds the row to move point to, advances by
 20065              the Y coordinate of the _next_ row, see the definition of
 20066              MATRIX_ROW_BOTTOM_Y.  */
 20067           if (w->cursor.vpos < margin + tab_line + header_line)
 20068             {
 20069               w->cursor.vpos = -1;
 20070               clear_glyph_matrix (w->desired_matrix);
 20071               goto try_to_scroll;
 20072             }
 20073           else
 20074             {
 20075               int window_height = window_box_height (w);
 20076 
 20077               if (tab_line)
 20078                 window_height += CURRENT_TAB_LINE_HEIGHT (w);
 20079               if (header_line)
 20080                 window_height += CURRENT_HEADER_LINE_HEIGHT (w);
 20081               if (w->cursor.y >= window_height - pixel_margin)
 20082                 {
 20083                   w->cursor.vpos = -1;
 20084                   clear_glyph_matrix (w->desired_matrix);
 20085                   goto try_to_scroll;
 20086                 }
 20087             }
 20088         }
 20089 
 20090       /* If we need to move point for either of the above reasons,
 20091          now actually do it.  */
 20092       if (new_vpos >= 0)
 20093         {
 20094           struct glyph_row *row;
 20095 
 20096           row = MATRIX_FIRST_TEXT_ROW (w->desired_matrix);
 20097           while (MATRIX_ROW_BOTTOM_Y (row) < new_vpos
 20098                  && !row->ends_at_zv_p)
 20099             ++row;
 20100 
 20101           TEMP_SET_PT_BOTH (MATRIX_ROW_START_CHARPOS (row),
 20102                             MATRIX_ROW_START_BYTEPOS (row));
 20103 
 20104           if (w != XWINDOW (selected_window))
 20105             set_marker_both (w->pointm, Qnil, PT, PT_BYTE);
 20106           else if (current_buffer == old)
 20107             SET_TEXT_POS (lpoint, PT, PT_BYTE);
 20108 
 20109           set_cursor_from_row (w, row, w->desired_matrix, 0, 0, 0, 0);
 20110 
 20111           /* Re-run pre-redisplay-function so it can update the region
 20112              according to the new position of point.  */
 20113           /* Other than the cursor, w's redisplay is done so we can set its
 20114              redisplay to false.  Also the buffer's redisplay can be set to
 20115              false, since propagate_buffer_redisplay should have already
 20116              propagated its info to `w' anyway.  */
 20117           w->redisplay = false;
 20118           XBUFFER (w->contents)->text->redisplay = false;
 20119           safe__call1 (true, Vpre_redisplay_function, Fcons (window, Qnil));
 20120 
 20121           if (w->redisplay || XBUFFER (w->contents)->text->redisplay
 20122               || ((EQ (Vdisplay_line_numbers, Qrelative)
 20123                    || EQ (Vdisplay_line_numbers, Qvisual))
 20124                   && row != MATRIX_FIRST_TEXT_ROW (w->desired_matrix)))
 20125             {
 20126               /* Either pre-redisplay-function made changes (e.g. move
 20127                  the region), or we moved point in a window that is
 20128                  under display-line-numbers = relative mode.  We need
 20129                  another round of redisplay.  */
 20130               clear_glyph_matrix (w->desired_matrix);
 20131               if (!try_window (window, startp, 0))
 20132                 goto need_larger_matrices;
 20133             }
 20134         }
 20135       if (w->cursor.vpos < 0
 20136           || !cursor_row_fully_visible_p (w, false, false, false))
 20137         {
 20138           clear_glyph_matrix (w->desired_matrix);
 20139           goto try_to_scroll;
 20140         }
 20141 
 20142 #ifdef GLYPH_DEBUG
 20143       debug_method_add (w, "forced window start");
 20144 #endif
 20145       goto done;
 20146     }
 20147 
 20148  ignore_start:
 20149 
 20150   /* Handle case where text has not changed, only point, and it has
 20151      not moved off the frame, and we are not retrying after hscroll.
 20152      (current_matrix_up_to_date_p is true when retrying.)  */
 20153   if (current_matrix_up_to_date_p
 20154       && (rc = try_cursor_movement (window, startp, &temp_scroll_step),
 20155           rc != CURSOR_MOVEMENT_CANNOT_BE_USED))
 20156     {
 20157       switch (rc)
 20158         {
 20159         case CURSOR_MOVEMENT_SUCCESS:
 20160           used_current_matrix_p = true;
 20161           goto done;
 20162 
 20163         case CURSOR_MOVEMENT_MUST_SCROLL:
 20164           goto try_to_scroll;
 20165 
 20166         default:
 20167           emacs_abort ();
 20168         }
 20169     }
 20170   /* If current starting point was originally the beginning of a line
 20171      but no longer is, or if the starting point is invisible but the
 20172      buffer wants it always visible, find a new starting point.  */
 20173   else if (w->start_at_line_beg
 20174            && ((CHARPOS (startp) > BEGV
 20175                 && FETCH_BYTE (BYTEPOS (startp) - 1) != '\n')
 20176                || (CHARPOS (startp) >= BEGV
 20177                    && CHARPOS (startp) <= ZV
 20178                    && !window_start_acceptable_p (window, CHARPOS (startp)))))
 20179     {
 20180 #ifdef GLYPH_DEBUG
 20181       debug_method_add (w, "recenter 1");
 20182 #endif
 20183       goto recenter;
 20184     }
 20185 
 20186   /* Try scrolling with try_window_id.  Value is > 0 if update has
 20187      been done, it is -1 if we know that the same window start will
 20188      not work.  It is 0 if unsuccessful for some other reason.  */
 20189   else if ((tem = try_window_id (w)) != 0)
 20190     {
 20191 #ifdef GLYPH_DEBUG
 20192       debug_method_add (w, "try_window_id %d", tem);
 20193 #endif
 20194 
 20195       if (f->fonts_changed)
 20196         goto need_larger_matrices;
 20197       if (tem > 0)
 20198         goto done;
 20199 
 20200       /* Otherwise try_window_id has returned -1 which means that we
 20201          don't want the alternative below this comment to execute.  */
 20202     }
 20203   else if (CHARPOS (startp) >= BEGV
 20204            && CHARPOS (startp) <= ZV
 20205            && PT >= CHARPOS (startp)
 20206            && (CHARPOS (startp) < ZV
 20207                /* Avoid starting at end of buffer.  */
 20208                || CHARPOS (startp) == BEGV
 20209                || !window_outdated (w)))
 20210     {
 20211       int d1, d2, d5, d6;
 20212       int rtop, rbot;
 20213 
 20214       /* If first window line is a continuation line, and window start
 20215          is inside the modified region, but the first change is before
 20216          current window start, we must select a new window start.
 20217 
 20218          However, if this is the result of a down-mouse event (e.g. by
 20219          extending the mouse-drag-overlay), we don't want to select a
 20220          new window start, since that would change the position under
 20221          the mouse, resulting in an unwanted mouse-movement rather
 20222          than a simple mouse-click.  */
 20223       if (!w->start_at_line_beg
 20224           && NILP (track_mouse)
 20225           && CHARPOS (startp) > BEGV
 20226           && CHARPOS (startp) > BEG + beg_unchanged
 20227           && CHARPOS (startp) <= Z - end_unchanged
 20228           /* Even if w->start_at_line_beg is nil, a new window may
 20229              start at a line_beg, since that's how set_buffer_window
 20230              sets it.  So, we need to check the return value of
 20231              compute_window_start_on_continuation_line.  (See also
 20232              bug#197).  */
 20233           && XMARKER (w->start)->buffer == current_buffer
 20234           && compute_window_start_on_continuation_line (w)
 20235           /* It doesn't make sense to force the window start like we
 20236              do at label force_start if it is already known that point
 20237              will not be fully visible in the resulting window, because
 20238              doing so will move point from its correct position
 20239              instead of scrolling the window to bring point into view.
 20240              See bug#9324.  */
 20241           && pos_visible_p (w, PT, &d1, &d2, &rtop, &rbot, &d5, &d6)
 20242           /* A very tall row could need more than the window height,
 20243              in which case we accept that it is partially visible.  */
 20244           && (rtop != 0) == (rbot != 0))
 20245         {
 20246           w->force_start = true;
 20247           SET_TEXT_POS_FROM_MARKER (startp, w->start);
 20248 #ifdef GLYPH_DEBUG
 20249           debug_method_add (w, "recomputed window start in continuation line");
 20250 #endif
 20251           goto force_start;
 20252         }
 20253 
 20254       /* Don't use the same window-start if it is invisible or covered
 20255          by a replacing 'display' property and the buffer requested
 20256          the window-start to be always visible.  */
 20257       if (!window_start_acceptable_p (window, CHARPOS (startp)))
 20258         {
 20259 #ifdef GLYPH_DEBUG
 20260           debug_method_add (w, "recenter 2");
 20261 #endif
 20262           goto recenter;
 20263         }
 20264 
 20265 #ifdef GLYPH_DEBUG
 20266       debug_method_add (w, "same window start");
 20267 #endif
 20268 
 20269       /* Try to redisplay starting at same place as before.
 20270          If point has not moved off frame, accept the results.  */
 20271       if (!current_matrix_up_to_date_p
 20272           /* Don't use try_window_reusing_current_matrix in this case
 20273              because a window scroll function can have changed the
 20274              buffer.  */
 20275           || !NILP (Vwindow_scroll_functions)
 20276           || MINI_WINDOW_P (w)
 20277           || !(used_current_matrix_p
 20278                = try_window_reusing_current_matrix (w)))
 20279         {
 20280           IF_DEBUG (debug_method_add (w, "1"));
 20281           clear_glyph_matrix (w->desired_matrix);
 20282           if (try_window (window, startp, TRY_WINDOW_CHECK_MARGINS) < 0)
 20283             /* -1 means we need to scroll.
 20284                0 means we need new matrices, but fonts_changed
 20285                is set in that case, so we will detect it below.  */
 20286             goto try_to_scroll;
 20287         }
 20288 
 20289       if (f->fonts_changed)
 20290         goto need_larger_matrices;
 20291 
 20292       if (w->cursor.vpos >= 0)
 20293         {
 20294           if (!just_this_one_p
 20295               || current_buffer->clip_changed
 20296               || BEG_UNCHANGED < CHARPOS (startp))
 20297             /* Forget any recorded base line for line number display.  */
 20298             w->base_line_number = 0;
 20299 
 20300           if (!cursor_row_fully_visible_p (w, true, false, false))
 20301             {
 20302               clear_glyph_matrix (w->desired_matrix);
 20303               last_line_misfit = true;
 20304             }
 20305             /* Drop through and scroll.  */
 20306           else
 20307             goto done;
 20308         }
 20309       else
 20310         clear_glyph_matrix (w->desired_matrix);
 20311     }
 20312 
 20313  try_to_scroll:
 20314 
 20315   /* Redisplay the mode line.  Select the buffer properly for that.  */
 20316   if (!update_mode_line)
 20317     {
 20318       update_mode_line = true;
 20319       w->update_mode_line = true;
 20320     }
 20321 
 20322   /* Try to scroll by specified few lines.  */
 20323   if ((0 < scroll_conservatively
 20324        /* FIXME: the option is supposed to affect minibuffers, but we
 20325           test MINI_WINDOW_P, which can also catch uses of
 20326           mini-windows for displaying the echo area.  Do we need to
 20327           distinguish these two use cases?  */
 20328        || (scroll_minibuffer_conservatively && MINI_WINDOW_P (w))
 20329        || 0 < emacs_scroll_step
 20330        || temp_scroll_step
 20331        || NUMBERP (BVAR (current_buffer, scroll_up_aggressively))
 20332        || NUMBERP (BVAR (current_buffer, scroll_down_aggressively)))
 20333       && CHARPOS (startp) >= BEGV
 20334       && CHARPOS (startp) <= ZV)
 20335     {
 20336       /* The function returns -1 if new fonts were loaded, 1 if
 20337          successful, 0 if not successful.  */
 20338       int ss = try_scrolling (window, just_this_one_p,
 20339                               ((scroll_minibuffer_conservatively
 20340                                 && MINI_WINDOW_P (w))
 20341                                ? SCROLL_LIMIT + 1
 20342                                : scroll_conservatively),
 20343                               emacs_scroll_step,
 20344                               temp_scroll_step, last_line_misfit);
 20345       switch (ss)
 20346         {
 20347         case SCROLLING_SUCCESS:
 20348           goto done;
 20349 
 20350         case SCROLLING_NEED_LARGER_MATRICES:
 20351           goto need_larger_matrices;
 20352 
 20353         case SCROLLING_FAILED:
 20354           break;
 20355 
 20356         default:
 20357           emacs_abort ();
 20358         }
 20359     }
 20360 
 20361   /* Finally, just choose a place to start which positions point
 20362      according to user preferences.  */
 20363 
 20364  recenter:
 20365 
 20366 #ifdef GLYPH_DEBUG
 20367   debug_method_add (w, "recenter");
 20368 #endif
 20369 
 20370   /* Forget any previously recorded base line for line number display.  */
 20371   if (!buffer_unchanged_p)
 20372     w->base_line_number = 0;
 20373 
 20374   /* Determine the window start relative to point.  */
 20375   init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
 20376   it.current_y = it.last_visible_y;
 20377   if (centering_position < 0)
 20378     {
 20379       ptrdiff_t margin_pos = CHARPOS (startp);
 20380       Lisp_Object aggressive;
 20381       bool scrolling_up;
 20382 
 20383       /* If there is a scroll margin at the top of the window, find
 20384          its character position.  */
 20385       if (margin
 20386           /* Cannot call start_display if startp is not in the
 20387              accessible region of the buffer.  This can happen when we
 20388              have just switched to a different buffer and/or changed
 20389              its restriction.  In that case, startp is initialized to
 20390              the character position 1 (BEGV) because we did not yet
 20391              have chance to display the buffer even once.  */
 20392           && BEGV <= CHARPOS (startp) && CHARPOS (startp) <= ZV)
 20393         {
 20394           struct it it1;
 20395           void *it1data = NULL;
 20396 
 20397           SAVE_IT (it1, it, it1data);
 20398           start_display (&it1, w, startp);
 20399           move_it_vertically (&it1, margin * frame_line_height);
 20400           margin_pos = IT_CHARPOS (it1);
 20401           RESTORE_IT (&it, &it, it1data);
 20402         }
 20403       scrolling_up = PT > margin_pos;
 20404       aggressive =
 20405         scrolling_up
 20406         ? BVAR (current_buffer, scroll_up_aggressively)
 20407         : BVAR (current_buffer, scroll_down_aggressively);
 20408 
 20409       if (!MINI_WINDOW_P (w)
 20410           && (scroll_conservatively > SCROLL_LIMIT || NUMBERP (aggressive)))
 20411         {
 20412           int pt_offset = 0;
 20413 
 20414           /* Setting scroll-conservatively overrides
 20415              scroll-*-aggressively.  */
 20416           if (!scroll_conservatively && NUMBERP (aggressive))
 20417             {
 20418               double float_amount = XFLOATINT (aggressive);
 20419 
 20420               pt_offset = float_amount * WINDOW_BOX_TEXT_HEIGHT (w);
 20421               if (pt_offset == 0 && float_amount > 0)
 20422                 pt_offset = 1;
 20423               if (pt_offset && margin > 0)
 20424                 margin -= 1;
 20425             }
 20426           /* Compute how much to move the window start backward from
 20427              point so that point will be displayed where the user
 20428              wants it.  */
 20429           if (scrolling_up)
 20430             {
 20431               centering_position = it.last_visible_y;
 20432               if (pt_offset)
 20433                 centering_position -= pt_offset;
 20434               centering_position -=
 20435                 (frame_line_height * (1 + margin + last_line_misfit)
 20436                  + WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w));
 20437               /* Don't let point enter the scroll margin near top of
 20438                  the window.  */
 20439               if (centering_position < margin * frame_line_height)
 20440                 centering_position = margin * frame_line_height;
 20441             }
 20442           else
 20443             centering_position = margin * frame_line_height + pt_offset;
 20444         }
 20445       else
 20446         /* Set the window start half the height of the window backward
 20447            from point.  */
 20448         centering_position = window_box_height (w) / 2;
 20449     }
 20450   if (current_buffer->long_line_optimizations_p
 20451       && it.line_wrap == TRUNCATE)
 20452     {
 20453       /* For very long and truncated lines, go back using a simplified
 20454          method, which ignored any inaccuracies due to line-height
 20455          differences, display properties/overlays, etc.  */
 20456       int nlines = centering_position / frame_line_height;
 20457 
 20458       while (nlines-- && IT_CHARPOS (it) > BEGV)
 20459         back_to_previous_visible_line_start (&it);
 20460       reseat_1 (&it, it.current.pos, true);
 20461     }
 20462   else
 20463     move_it_vertically_backward (&it, centering_position);
 20464 
 20465   eassert (IT_CHARPOS (it) >= BEGV);
 20466 
 20467   /* The function move_it_vertically_backward may move over more
 20468      than the specified y-distance.  If it->w is small, e.g. a
 20469      mini-buffer window, we may end up in front of the window's
 20470      display area.  Start displaying at the start of the line
 20471      containing PT in this case.  */
 20472   if (it.current_y <= 0)
 20473     {
 20474       init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
 20475       move_it_vertically_backward (&it, 0);
 20476       it.current_y = 0;
 20477     }
 20478 
 20479   it.current_x = it.hpos = 0;
 20480 
 20481   /* Set the window start position here explicitly, to avoid an
 20482      infinite loop in case the functions in window-scroll-functions
 20483      get errors.  */
 20484   set_marker_both (w->start, Qnil, IT_CHARPOS (it), IT_BYTEPOS (it));
 20485 
 20486   /* Run scroll hooks.  */
 20487   startp = run_window_scroll_functions (window, it.current.pos);
 20488 
 20489   /* We invoke try_window and try_window_reusing_current_matrix below,
 20490      and they manipulate the bidi cache.  Save and restore the cache
 20491      state of our iterator, so we could continue using it after that.  */
 20492   itdata = bidi_shelve_cache ();
 20493 
 20494   /* Redisplay the window.  */
 20495   use_desired_matrix = false;
 20496   if (!current_matrix_up_to_date_p
 20497       || windows_or_buffers_changed
 20498       || f->cursor_type_changed
 20499       /* Don't use try_window_reusing_current_matrix in this case
 20500          because it can have changed the buffer.  */
 20501       || !NILP (Vwindow_scroll_functions)
 20502       || !just_this_one_p
 20503       || MINI_WINDOW_P (w)
 20504       || !(used_current_matrix_p
 20505            = try_window_reusing_current_matrix (w)))
 20506     use_desired_matrix = (try_window (window, startp, 0) == 1);
 20507 
 20508   bidi_unshelve_cache (itdata, false);
 20509 
 20510   /* If new fonts have been loaded (due to fontsets), give up.  We
 20511      have to start a new redisplay since we need to re-adjust glyph
 20512      matrices.  */
 20513   if (f->fonts_changed)
 20514     goto need_larger_matrices;
 20515 
 20516   /* If cursor did not appear assume that the middle of the window is
 20517      in the first line of the window.  Do it again with the next line.
 20518      (Imagine a window of height 100, displaying two lines of height
 20519      60.  Moving back 50 from it->last_visible_y will end in the first
 20520      line.)  */
 20521   if (w->cursor.vpos < 0)
 20522     {
 20523       if (w->window_end_valid && PT >= Z - w->window_end_pos)
 20524         {
 20525           clear_glyph_matrix (w->desired_matrix);
 20526           move_it_by_lines (&it, 1);
 20527           try_window (window, it.current.pos, 0);
 20528         }
 20529       else if (PT < IT_CHARPOS (it))
 20530         {
 20531           clear_glyph_matrix (w->desired_matrix);
 20532           move_it_by_lines (&it, -1);
 20533           try_window (window, it.current.pos, 0);
 20534         }
 20535       else if (scroll_conservatively > SCROLL_LIMIT
 20536                && (it.method == GET_FROM_STRING
 20537                    || overlay_touches_p (IT_CHARPOS (it)))
 20538                && IT_CHARPOS (it) < ZV)
 20539         {
 20540           /* If the window starts with a before-string that spans more
 20541              than one screen line, using that position to display the
 20542              window might fail to bring point into the view, because
 20543              start_display will always start by displaying the string,
 20544              whereas the code above determines where to set w->start
 20545              by the buffer position of the place where it takes screen
 20546              coordinates.  Try to recover by finding the next screen
 20547              line that displays buffer text.  */
 20548           ptrdiff_t pos0 = IT_CHARPOS (it);
 20549 
 20550           clear_glyph_matrix (w->desired_matrix);
 20551           do {
 20552             move_it_by_lines (&it, 1);
 20553           } while (IT_CHARPOS (it) == pos0);
 20554           try_window (window, it.current.pos, 0);
 20555         }
 20556       else
 20557         {
 20558           /* Not much we can do about it.  */
 20559         }
 20560     }
 20561 
 20562   /* Consider the following case: Window starts at BEGV, there is
 20563      invisible, intangible text at BEGV, so that display starts at
 20564      some point START > BEGV.  It can happen that we are called with
 20565      PT somewhere between BEGV and START.  Try to handle that case,
 20566      and similar ones.  */
 20567   if (w->cursor.vpos < 0)
 20568     {
 20569       /* Prefer the desired matrix to the current matrix, if possible,
 20570          in the fallback calculations below.  This is because using
 20571          the current matrix might completely goof, e.g. if its first
 20572          row is after point.  */
 20573       struct glyph_matrix *matrix =
 20574         use_desired_matrix ? w->desired_matrix : w->current_matrix;
 20575       /* First, try locating the proper glyph row for PT.  */
 20576       struct glyph_row *row =
 20577         row_containing_pos (w, PT, matrix->rows, NULL, 0);
 20578 
 20579       /* Sometimes point is at the beginning of invisible text that is
 20580          before the 1st character displayed in the row.  In that case,
 20581          row_containing_pos fails to find the row, because no glyphs
 20582          with appropriate buffer positions are present in the row.
 20583          Therefore, we next try to find the row which shows the 1st
 20584          position after the invisible text.  */
 20585       if (!row)
 20586         {
 20587           Lisp_Object val =
 20588             get_char_property_and_overlay (make_fixnum (PT), Qinvisible,
 20589                                            Qnil, NULL);
 20590 
 20591           if (TEXT_PROP_MEANS_INVISIBLE (val) != 0)
 20592             {
 20593               ptrdiff_t alt_pos;
 20594               Lisp_Object invis_end =
 20595                 Fnext_single_char_property_change (make_fixnum (PT), Qinvisible,
 20596                                                    Qnil, Qnil);
 20597 
 20598               if (FIXNATP (invis_end))
 20599                 alt_pos = XFIXNAT (invis_end);
 20600               else
 20601                 alt_pos = ZV;
 20602               row = row_containing_pos (w, alt_pos, matrix->rows, NULL, 0);
 20603             }
 20604         }
 20605       /* Finally, fall back on the first row of the window after the
 20606          tab-line and header line (if any).  This is slightly better
 20607          than not displaying the cursor at all.  */
 20608       if (!row)
 20609         {
 20610           row = matrix->rows;
 20611           /* Skip the tab-line and header-line rows, if any.  */
 20612           if (row->tab_line_p)
 20613             ++row;
 20614           if (row->mode_line_p)
 20615             ++row;
 20616         }
 20617       set_cursor_from_row (w, row, matrix, 0, 0, 0, 0);
 20618     }
 20619 
 20620   if (!cursor_row_fully_visible_p (w, false, false, false))
 20621     {
 20622       /* If vscroll is enabled, disable it and try again.  */
 20623       if (w->vscroll)
 20624         {
 20625           w->vscroll = 0;
 20626           clear_glyph_matrix (w->desired_matrix);
 20627           goto recenter;
 20628         }
 20629 
 20630       /* Users who set scroll-conservatively to a large number want
 20631          point just above/below the scroll margin.  If we ended up
 20632          with point's row partially visible, move the window start to
 20633          make that row fully visible and out of the margin.  */
 20634       if (scroll_conservatively > SCROLL_LIMIT)
 20635         {
 20636           int window_total_lines
 20637             = WINDOW_TOTAL_LINES (w) * FRAME_LINE_HEIGHT (f) / frame_line_height;
 20638           bool move_down = w->cursor.vpos >= window_total_lines / 2;
 20639 
 20640           move_it_by_lines (&it, move_down ? margin + 1 : -(margin + 1));
 20641           clear_glyph_matrix (w->desired_matrix);
 20642           if (1 == try_window (window, it.current.pos,
 20643                                TRY_WINDOW_CHECK_MARGINS))
 20644             goto done;
 20645         }
 20646 
 20647       /* If centering point failed to make the whole line visible,
 20648          put point at the top instead.  That has to make the whole line
 20649          visible, if it can be done.  */
 20650       if (centering_position == 0)
 20651         goto done;
 20652 
 20653       clear_glyph_matrix (w->desired_matrix);
 20654       centering_position = 0;
 20655       goto recenter;
 20656     }
 20657 
 20658  done:
 20659 
 20660   SET_TEXT_POS_FROM_MARKER (startp, w->start);
 20661   w->start_at_line_beg = (CHARPOS (startp) == BEGV
 20662                           || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n');
 20663 
 20664   /* Display the mode line, header line, and tab-line, if we must.  */
 20665   if ((update_mode_line
 20666        /* If window not full width, must redo its mode line
 20667           if (a) the window to its side is being redone and
 20668           (b) we do a frame-based redisplay.  This is a consequence
 20669           of how inverted lines are drawn in frame-based redisplay.  */
 20670        || (!just_this_one_p
 20671            && !FRAME_WINDOW_P (f)
 20672            && !WINDOW_FULL_WIDTH_P (w))
 20673        /* Line number to display.  */
 20674        || w->base_line_pos > 0
 20675        /* Column number is displayed and different from the one displayed.  */
 20676        || (w->column_number_displayed != -1
 20677            && (w->column_number_displayed != current_column ())))
 20678       /* This means that the window has a mode line.  */
 20679       && (window_wants_mode_line (w)
 20680           || window_wants_header_line (w)
 20681           || window_wants_tab_line (w)))
 20682     {
 20683       specpdl_ref count1 = SPECPDL_INDEX ();
 20684 
 20685       specbind (Qinhibit_quit, Qt);
 20686       display_mode_lines (w);
 20687       unbind_to (count1, Qnil);
 20688 
 20689       /* If mode line height has changed, arrange for a thorough
 20690          immediate redisplay using the correct mode line height.  */
 20691       if (window_wants_mode_line (w)
 20692           && CURRENT_MODE_LINE_HEIGHT (w) != DESIRED_MODE_LINE_HEIGHT (w))
 20693         {
 20694           f->fonts_changed = true;
 20695           w->mode_line_height = -1;
 20696           MATRIX_MODE_LINE_ROW (w->current_matrix)->height
 20697             = DESIRED_MODE_LINE_HEIGHT (w);
 20698         }
 20699 
 20700       /* If tab line height has changed, arrange for a thorough
 20701          immediate redisplay using the correct tab line height.  */
 20702       if (window_wants_tab_line (w)
 20703           && CURRENT_TAB_LINE_HEIGHT (w) != DESIRED_TAB_LINE_HEIGHT (w))
 20704         {
 20705           f->fonts_changed = true;
 20706           w->tab_line_height = -1;
 20707           MATRIX_TAB_LINE_ROW (w->current_matrix)->height
 20708             = DESIRED_TAB_LINE_HEIGHT (w);
 20709         }
 20710 
 20711       /* If header line height has changed, arrange for a thorough
 20712          immediate redisplay using the correct header line height.  */
 20713       if (window_wants_header_line (w)
 20714           && CURRENT_HEADER_LINE_HEIGHT (w) != DESIRED_HEADER_LINE_HEIGHT (w))
 20715         {
 20716           f->fonts_changed = true;
 20717           w->header_line_height = -1;
 20718           MATRIX_HEADER_LINE_ROW (w->current_matrix)->height
 20719             = DESIRED_HEADER_LINE_HEIGHT (w);
 20720         }
 20721 
 20722       if (f->fonts_changed)
 20723         goto need_larger_matrices;
 20724     }
 20725 
 20726   if (!line_number_displayed && w->base_line_pos != -1)
 20727     {
 20728       w->base_line_pos = 0;
 20729       w->base_line_number = 0;
 20730     }
 20731 
 20732  finish_menu_bars:
 20733 
 20734   /* When we reach a frame's selected window, redo the frame's menu
 20735      bar, tool bar, tab-bar, and the frame's title.  */
 20736   if (update_mode_line
 20737       && EQ (FRAME_SELECTED_WINDOW (f), window))
 20738     {
 20739       bool redisplay_menu_p;
 20740 
 20741       if (FRAME_WINDOW_P (f))
 20742         {
 20743 #ifdef HAVE_EXT_MENU_BAR
 20744           redisplay_menu_p = FRAME_EXTERNAL_MENU_BAR (f);
 20745 #else
 20746           redisplay_menu_p = FRAME_MENU_BAR_LINES (f) > 0;
 20747 #endif
 20748         }
 20749       else
 20750         redisplay_menu_p = FRAME_MENU_BAR_LINES (f) > 0;
 20751 
 20752       if (redisplay_menu_p)
 20753         display_menu_bar (w);
 20754 
 20755 #ifdef HAVE_WINDOW_SYSTEM
 20756       if (FRAME_WINDOW_P (f))
 20757         {
 20758           if (WINDOWP (f->tab_bar_window)
 20759               && (FRAME_TAB_BAR_LINES (f) > 0
 20760                   || !NILP (Vauto_resize_tab_bars))
 20761               && redisplay_tab_bar (f))
 20762             ignore_mouse_drag_p = true;
 20763 
 20764 #ifdef HAVE_EXT_TOOL_BAR
 20765           if (FRAME_EXTERNAL_TOOL_BAR (f))
 20766             update_frame_tool_bar (f);
 20767 #else
 20768           if (WINDOWP (f->tool_bar_window)
 20769               && (FRAME_TOOL_BAR_LINES (f) > 0
 20770                   || !NILP (Vauto_resize_tool_bars))
 20771               && redisplay_tool_bar (f))
 20772             ignore_mouse_drag_p = true;
 20773 #endif
 20774         }
 20775       else
 20776         {
 20777           if ((FRAME_TAB_BAR_LINES (f) > 0))
 20778             display_tab_bar (w);
 20779         }
 20780 
 20781       gui_consider_frame_title (w->frame);
 20782 #else
 20783       if ((FRAME_TAB_BAR_LINES (f) > 0))
 20784         display_tab_bar (w);
 20785 #endif
 20786     }
 20787 
 20788 #ifdef HAVE_WINDOW_SYSTEM
 20789   if (FRAME_WINDOW_P (f)
 20790       && update_window_fringes (w, (just_this_one_p
 20791                                     || (!used_current_matrix_p && !overlay_arrow_seen)
 20792                                     || w->pseudo_window_p)))
 20793     {
 20794       update_begin (f);
 20795       block_input ();
 20796       if (draw_window_fringes (w, true))
 20797         {
 20798           if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
 20799             gui_draw_right_divider (w);
 20800           else
 20801             gui_draw_vertical_border (w);
 20802         }
 20803       unblock_input ();
 20804       update_end (f);
 20805     }
 20806 
 20807   if (WINDOW_BOTTOM_DIVIDER_WIDTH (w))
 20808     gui_draw_bottom_divider (w);
 20809 #endif /* HAVE_WINDOW_SYSTEM */
 20810 
 20811   /* We go to this label, with fonts_changed set, if it is
 20812      necessary to try again using larger glyph matrices.
 20813      We have to redeem the scroll bar even in this case,
 20814      because the loop in redisplay_internal expects that.  */
 20815  need_larger_matrices:
 20816   ;
 20817  finish_scroll_bars:
 20818 
 20819    if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w) || WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w))
 20820     {
 20821       if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
 20822         /* Set the thumb's position and size.  */
 20823         set_vertical_scroll_bar (w);
 20824 
 20825       if (WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w))
 20826         /* Set the thumb's position and size.  */
 20827         set_horizontal_scroll_bar (w);
 20828 
 20829       /* Note that we actually used the scroll bar attached to this
 20830          window, so it shouldn't be deleted at the end of redisplay.  */
 20831       if (FRAME_TERMINAL (f)->redeem_scroll_bar_hook)
 20832         (*FRAME_TERMINAL (f)->redeem_scroll_bar_hook) (w);
 20833     }
 20834 
 20835   /* Restore current_buffer and value of point in it.  The window
 20836      update may have changed the buffer, so first make sure `opoint'
 20837      is still valid (Bug#6177).  */
 20838   if (CHARPOS (opoint) < BEGV)
 20839     TEMP_SET_PT_BOTH (BEGV, BEGV_BYTE);
 20840   else if (CHARPOS (opoint) > ZV)
 20841     TEMP_SET_PT_BOTH (Z, Z_BYTE);
 20842   else
 20843     TEMP_SET_PT_BOTH (CHARPOS (opoint), BYTEPOS (opoint));
 20844 
 20845   set_buffer_internal_1 (old);
 20846   /* Avoid an abort in TEMP_SET_PT_BOTH if the buffer has become
 20847      shorter.  This can be caused by log truncation in *Messages*.  */
 20848   if (CHARPOS (lpoint) <= ZV)
 20849     TEMP_SET_PT_BOTH (CHARPOS (lpoint), BYTEPOS (lpoint));
 20850 
 20851   unbind_to (count, Qnil);
 20852 }
 20853 
 20854 
 20855 /* Build the complete desired matrix of WINDOW with a window start
 20856    buffer position POS.
 20857 
 20858    Value is 1 if successful.  It is zero if fonts were loaded during
 20859    redisplay or the dimensions of the desired matrix were found
 20860    insufficient, which makes re-adjusting glyph matrices necessary.
 20861    Value is -1 if point would appear in the scroll margins.  (We check
 20862    the former only if TRY_WINDOW_IGNORE_FONTS_CHANGE is unset in
 20863    FLAGS, and the latter only if TRY_WINDOW_CHECK_MARGINS is set in
 20864    FLAGS.)
 20865 
 20866    Note that 'x-show-tip' invokes this function in a special way, and
 20867    in that case the return value of zero doesn't necessarily mean the
 20868    glyph matrices need to be re-adjusted, if the entire text of the
 20869    tooltip was processed and has its glyphs in the matrix's glyph
 20870    rows, i.e. if the dimensions of the matrix were found insufficient
 20871    while producing empty glyph rows beyond ZV.  */
 20872 
 20873 int
 20874 try_window (Lisp_Object window, struct text_pos pos, int flags)
 20875 {
 20876   struct window *w = XWINDOW (window);
 20877   struct it it;
 20878   struct glyph_row *last_text_row = NULL;
 20879   struct frame *f = XFRAME (w->frame);
 20880   int cursor_vpos = w->cursor.vpos;
 20881 
 20882   /* Make POS the new window start.  */
 20883   set_marker_both (w->start, Qnil, CHARPOS (pos), BYTEPOS (pos));
 20884 
 20885   /* Mark cursor position as unknown.  No overlay arrow seen.  */
 20886   w->cursor.vpos = -1;
 20887   overlay_arrow_seen = false;
 20888 
 20889   /* Initialize iterator and info to start at POS.  */
 20890   start_display (&it, w, pos);
 20891   it.glyph_row->reversed_p = false;
 20892 
 20893   /* Display all lines of W.  */
 20894   while (it.current_y < it.last_visible_y)
 20895     {
 20896       int last_row_scale = it.w->nrows_scale_factor;
 20897       int last_col_scale = it.w->ncols_scale_factor;
 20898       if (display_line (&it, cursor_vpos))
 20899         last_text_row = it.glyph_row - 1;
 20900       if (f->fonts_changed
 20901           && !((flags & TRY_WINDOW_IGNORE_FONTS_CHANGE)
 20902                /* If the matrix dimensions are insufficient, we _must_
 20903                   fail and let dispnew.c reallocate the matrix.  */
 20904                && last_row_scale == it.w->nrows_scale_factor
 20905                && last_col_scale == it.w->ncols_scale_factor))
 20906         return 0;
 20907     }
 20908 
 20909   /* Save the character position of 'it' before we call
 20910      'start_display' again.  */
 20911   ptrdiff_t it_charpos = IT_CHARPOS (it);
 20912 
 20913   /* Don't let the cursor end in the scroll margins.  However, when
 20914      the window is vscrolled, we leave it to vscroll to handle the
 20915      margins, see window_scroll_pixel_based.  */
 20916   if ((flags & TRY_WINDOW_CHECK_MARGINS)
 20917       && w->vscroll == 0
 20918       && !MINI_WINDOW_P (w))
 20919     {
 20920       int top_scroll_margin = window_scroll_margin (w, MARGIN_IN_PIXELS);
 20921       int bot_scroll_margin = top_scroll_margin;
 20922       if (window_wants_header_line (w))
 20923         top_scroll_margin += CURRENT_HEADER_LINE_HEIGHT (w);
 20924       if (window_wants_tab_line (w))
 20925         top_scroll_margin += CURRENT_TAB_LINE_HEIGHT (w);
 20926       start_display (&it, w, pos);
 20927 
 20928       if ((w->cursor.y >= 0
 20929            && w->cursor.y < top_scroll_margin
 20930            && CHARPOS (pos) > BEGV)
 20931           /* rms: considering make_cursor_line_fully_visible_p here
 20932              seems to give wrong results.  We don't want to recenter
 20933              when the last line is partly visible, we want to allow
 20934              that case to be handled in the usual way.  */
 20935           || w->cursor.y > (it.last_visible_y - partial_line_height (&it)
 20936                             - bot_scroll_margin - 1))
 20937         {
 20938           w->cursor.vpos = -1;
 20939           clear_glyph_matrix (w->desired_matrix);
 20940           return -1;
 20941         }
 20942     }
 20943 
 20944   /* If bottom moved off end of frame, change mode line percentage.  */
 20945   if (w->window_end_pos <= 0 && Z != it_charpos)
 20946     w->update_mode_line = true;
 20947 
 20948   /* Set window_end_pos to the offset of the last character displayed
 20949      on the window from the end of current_buffer.  Set
 20950      window_end_vpos to its row number.  */
 20951   if (last_text_row)
 20952     {
 20953       eassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row));
 20954       adjust_window_ends (w, last_text_row, false);
 20955       eassert
 20956         (MATRIX_ROW_DISPLAYS_TEXT_P (MATRIX_ROW (w->desired_matrix,
 20957                                                  w->window_end_vpos)));
 20958     }
 20959   else
 20960     {
 20961       w->window_end_bytepos = Z_BYTE - ZV_BYTE;
 20962       w->window_end_pos = Z - ZV;
 20963       w->window_end_vpos = 0;
 20964     }
 20965 
 20966   /* But that is not valid info until redisplay finishes.  */
 20967   w->window_end_valid = false;
 20968   return 1;
 20969 }
 20970 
 20971 
 20972 
 20973 /************************************************************************
 20974     Window redisplay reusing current matrix when buffer has not changed
 20975  ************************************************************************/
 20976 
 20977 /* Try redisplay of window W showing an unchanged buffer with a
 20978    different window start than the last time it was displayed by
 20979    reusing its current matrix.  Value is true if successful.
 20980    W->start is the new window start.  */
 20981 
 20982 static bool
 20983 try_window_reusing_current_matrix (struct window *w)
 20984 {
 20985   struct frame *f = XFRAME (w->frame);
 20986   struct glyph_row *bottom_row;
 20987   struct it it;
 20988   struct run run;
 20989   struct text_pos start, new_start;
 20990   int nrows_scrolled, i;
 20991   struct glyph_row *last_text_row;
 20992   struct glyph_row *last_reused_text_row;
 20993   struct glyph_row *start_row;
 20994   int start_vpos, min_y, max_y;
 20995 
 20996 #ifdef GLYPH_DEBUG
 20997   if (inhibit_try_window_reusing)
 20998     return false;
 20999 #endif
 21000 
 21001   if (/* This function doesn't handle terminal frames.  */
 21002       !FRAME_WINDOW_P (f)
 21003       /* Don't try to reuse the display if windows have been split
 21004          or such.  */
 21005       || windows_or_buffers_changed
 21006       || f->cursor_type_changed
 21007       /* This function cannot handle buffers where the overlay arrow
 21008          is shown on the fringes, because if the arrow position
 21009          changes, we cannot just reuse the current matrix.  */
 21010       || overlay_arrow_in_current_buffer_p ())
 21011     return false;
 21012 
 21013   /* Can't do this if showing trailing whitespace.  */
 21014   if (!NILP (Vshow_trailing_whitespace))
 21015     return false;
 21016 
 21017   /* If top-line visibility has changed, give up.  */
 21018   if (window_wants_tab_line (w)
 21019       != MATRIX_TAB_LINE_ROW (w->current_matrix)->mode_line_p)
 21020     return false;
 21021 
 21022   /* If top-line visibility has changed, give up.  */
 21023   if (window_wants_header_line (w)
 21024       != MATRIX_HEADER_LINE_ROW (w->current_matrix)->mode_line_p)
 21025     return false;
 21026 
 21027   /* Give up if old or new display is scrolled vertically.  We could
 21028      make this function handle this, but right now it doesn't.  */
 21029   start_row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 21030   if (w->vscroll || MATRIX_ROW_PARTIALLY_VISIBLE_P (w, start_row))
 21031     return false;
 21032 
 21033   /* Clear the desired matrix for the display below.  */
 21034   clear_glyph_matrix (w->desired_matrix);
 21035 
 21036   /* Give up if line numbers are being displayed, because reusing the
 21037      current matrix might use the wrong width for line-number
 21038      display.  */
 21039   if (!NILP (Vdisplay_line_numbers))
 21040     return false;
 21041 
 21042   /* Can't scroll the display of w32 GUI frames when position of point
 21043      is indicated by the system caret, because scrolling the display
 21044      will then "copy" the pixels used by the caret.  */
 21045 #ifdef HAVE_NTGUI
 21046   if (w32_use_visible_system_caret)
 21047     return false;
 21048 #endif
 21049 
 21050   /* The variable new_start now holds the new window start.  The old
 21051      start `start' can be determined from the current matrix.  */
 21052   SET_TEXT_POS_FROM_MARKER (new_start, w->start);
 21053   start = start_row->minpos;
 21054   start_vpos = MATRIX_ROW_VPOS (start_row, w->current_matrix);
 21055 
 21056   if (CHARPOS (new_start) <= CHARPOS (start))
 21057     {
 21058       /* Don't use this method if the display starts with an ellipsis
 21059          displayed for invisible text.  It's not easy to handle that case
 21060          below, and it's certainly not worth the effort since this is
 21061          not a frequent case.  */
 21062       if (in_ellipses_for_invisible_text_p (&start_row->start, w))
 21063         return false;
 21064 
 21065       IF_DEBUG (debug_method_add (w, "twu1"));
 21066 
 21067       /* Display up to a row that can be reused.  The variable
 21068          last_text_row is set to the last row displayed that displays
 21069          text.  Note that it.vpos == 0 if or if not there is a
 21070          header-line; it's not the same as the MATRIX_ROW_VPOS!  */
 21071       start_display (&it, w, new_start);
 21072       w->cursor.vpos = -1;
 21073       last_text_row = last_reused_text_row = NULL;
 21074 
 21075       while (it.current_y < it.last_visible_y && !f->fonts_changed)
 21076         {
 21077           /* If we have reached into the characters in the START row,
 21078              that means the line boundaries have changed.  So we
 21079              can't start copying with the row START.  Maybe it will
 21080              work to start copying with the following row.  */
 21081           while (IT_CHARPOS (it) > CHARPOS (start))
 21082             {
 21083               /* Advance to the next row as the "start".  */
 21084               start_row++;
 21085               start = start_row->minpos;
 21086               /* If there are no more rows to try, or just one, give up.  */
 21087               if (start_row == MATRIX_MODE_LINE_ROW (w->current_matrix) - 1
 21088                   || w->vscroll || MATRIX_ROW_PARTIALLY_VISIBLE_P (w, start_row)
 21089                   || CHARPOS (start) == ZV)
 21090                 {
 21091                   clear_glyph_matrix (w->desired_matrix);
 21092                   return false;
 21093                 }
 21094 
 21095               start_vpos = MATRIX_ROW_VPOS (start_row, w->current_matrix);
 21096             }
 21097           /* If we have reached alignment, we can copy the rest of the
 21098              rows.  */
 21099           if (IT_CHARPOS (it) == CHARPOS (start)
 21100               /* Don't accept "alignment" inside a display vector,
 21101                  since start_row could have started in the middle of
 21102                  that same display vector (thus their character
 21103                  positions match), and we have no way of telling if
 21104                  that is the case.  */
 21105               && it.current.dpvec_index < 0)
 21106             break;
 21107 
 21108           it.glyph_row->reversed_p = false;
 21109           if (display_line (&it, -1))
 21110             last_text_row = it.glyph_row - 1;
 21111 
 21112         }
 21113 
 21114       /* A value of current_y < last_visible_y means that we stopped
 21115          at the previous window start, which in turn means that we
 21116          have at least one reusable row.  */
 21117       if (it.current_y < it.last_visible_y)
 21118         {
 21119           struct glyph_row *row;
 21120 
 21121           /* IT.vpos always starts from 0; it counts text lines.  */
 21122           nrows_scrolled = it.vpos - (start_row - MATRIX_FIRST_TEXT_ROW (w->current_matrix));
 21123 
 21124           /* Find PT if not already found in the lines displayed.  */
 21125           if (w->cursor.vpos < 0)
 21126             {
 21127               int dy = it.current_y - start_row->y;
 21128 
 21129               row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 21130               row = row_containing_pos (w, PT, row, NULL, dy);
 21131               if (row)
 21132                 set_cursor_from_row (w, row, w->current_matrix, 0, 0,
 21133                                      dy, nrows_scrolled);
 21134               else
 21135                 {
 21136                   clear_glyph_matrix (w->desired_matrix);
 21137                   return false;
 21138                 }
 21139             }
 21140 
 21141           /* Scroll the display.  Do it before the current matrix is
 21142              changed.  The problem here is that update has not yet
 21143              run, i.e. part of the current matrix is not up to date.
 21144              scroll_run_hook will clear the cursor, and use the
 21145              current matrix to get the height of the row the cursor is
 21146              in.  */
 21147           run.current_y = start_row->y;
 21148           run.desired_y = it.current_y;
 21149           run.height = it.last_visible_y - it.current_y;
 21150 
 21151           if (run.height > 0 && run.current_y != run.desired_y)
 21152             {
 21153 #ifdef HAVE_WINDOW_SYSTEM
 21154               update_begin (f);
 21155               gui_update_window_begin (w);
 21156               FRAME_RIF (f)->clear_window_mouse_face (w);
 21157               FRAME_RIF (f)->scroll_run_hook (w, &run);
 21158               gui_update_window_end (w, false, false);
 21159               update_end (f);
 21160 #endif
 21161             }
 21162 
 21163           /* Shift current matrix down by nrows_scrolled lines.  */
 21164           bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
 21165           rotate_matrix (w->current_matrix,
 21166                          start_vpos,
 21167                          MATRIX_ROW_VPOS (bottom_row, w->current_matrix),
 21168                          nrows_scrolled);
 21169 
 21170           /* Disable lines that must be updated.  */
 21171           for (i = 0; i < nrows_scrolled; ++i)
 21172             (start_row + i)->enabled_p = false;
 21173 
 21174           /* Re-compute Y positions.  */
 21175           min_y = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
 21176           max_y = it.last_visible_y;
 21177           for (row = start_row + nrows_scrolled;
 21178                row < bottom_row;
 21179                ++row)
 21180             {
 21181               row->y = it.current_y;
 21182               row->visible_height = row->height;
 21183 
 21184               if (row->y < min_y)
 21185                 row->visible_height -= min_y - row->y;
 21186               if (row->y + row->height > max_y)
 21187                 row->visible_height -= row->y + row->height - max_y;
 21188               if (row->fringe_bitmap_periodic_p)
 21189                 row->redraw_fringe_bitmaps_p = true;
 21190 
 21191               it.current_y += row->height;
 21192 
 21193               if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
 21194                 last_reused_text_row = row;
 21195               if (MATRIX_ROW_BOTTOM_Y (row) >= it.last_visible_y)
 21196                 break;
 21197             }
 21198 
 21199           /* Disable lines in the current matrix which are now
 21200              below the window.  */
 21201           for (++row; row < bottom_row; ++row)
 21202             row->enabled_p = row->mode_line_p = row->tab_line_p = false;
 21203         }
 21204 
 21205       /* Update window_end_pos etc.; last_reused_text_row is the last
 21206          reused row from the current matrix containing text, if any.
 21207          The value of last_text_row is the last displayed line
 21208          containing text.  */
 21209       if (last_reused_text_row)
 21210         adjust_window_ends (w, last_reused_text_row, true);
 21211       else if (last_text_row)
 21212         adjust_window_ends (w, last_text_row, false);
 21213       else
 21214         {
 21215           /* This window must be completely empty.  */
 21216           w->window_end_bytepos = Z_BYTE - ZV_BYTE;
 21217           w->window_end_pos = Z - ZV;
 21218           w->window_end_vpos = 0;
 21219         }
 21220       w->window_end_valid = false;
 21221 
 21222       /* Update hint: don't try scrolling again in update_window.  */
 21223       w->desired_matrix->no_scrolling_p = true;
 21224 
 21225 #ifdef GLYPH_DEBUG
 21226       debug_method_add (w, "try_window_reusing_current_matrix 1");
 21227 #endif
 21228       return true;
 21229     }
 21230   else if (CHARPOS (new_start) > CHARPOS (start))
 21231     {
 21232       struct glyph_row *pt_row, *row;
 21233       struct glyph_row *first_reusable_row;
 21234       struct glyph_row *first_row_to_display;
 21235       int dy;
 21236       int yb = window_text_bottom_y (w);
 21237 
 21238       /* Find the row starting at new_start, if there is one.  Don't
 21239          reuse a partially visible line at the end.  */
 21240       first_reusable_row = start_row;
 21241       while (first_reusable_row->enabled_p
 21242              && MATRIX_ROW_BOTTOM_Y (first_reusable_row) < yb
 21243              && (MATRIX_ROW_START_CHARPOS (first_reusable_row)
 21244                  < CHARPOS (new_start)))
 21245         ++first_reusable_row;
 21246 
 21247       /* Give up if there is no row to reuse.  */
 21248       if (MATRIX_ROW_BOTTOM_Y (first_reusable_row) >= yb
 21249           || !first_reusable_row->enabled_p
 21250           || (MATRIX_ROW_START_CHARPOS (first_reusable_row)
 21251               != CHARPOS (new_start)))
 21252         return false;
 21253 
 21254       /* We can reuse fully visible rows beginning with
 21255          first_reusable_row to the end of the window.  Set
 21256          first_row_to_display to the first row that cannot be reused.
 21257          Set pt_row to the row containing point, if there is any.  */
 21258       pt_row = NULL;
 21259       for (first_row_to_display = first_reusable_row;
 21260            MATRIX_ROW_BOTTOM_Y (first_row_to_display) < yb;
 21261            ++first_row_to_display)
 21262         {
 21263           if (PT >= MATRIX_ROW_START_CHARPOS (first_row_to_display)
 21264               && (PT < MATRIX_ROW_END_CHARPOS (first_row_to_display)
 21265                   || (PT == MATRIX_ROW_END_CHARPOS (first_row_to_display)
 21266                       && first_row_to_display->ends_at_zv_p
 21267                       && pt_row == NULL)))
 21268             pt_row = first_row_to_display;
 21269         }
 21270 
 21271       if (first_row_to_display->y >= yb)
 21272         return false;
 21273 
 21274       /* Start displaying at the start of first_row_to_display.  */
 21275       init_to_row_start (&it, w, first_row_to_display);
 21276 
 21277       nrows_scrolled = (MATRIX_ROW_VPOS (first_reusable_row, w->current_matrix)
 21278                         - start_vpos);
 21279       it.vpos = (MATRIX_ROW_VPOS (first_row_to_display, w->current_matrix)
 21280                  - nrows_scrolled);
 21281       it.current_y = (first_row_to_display->y - first_reusable_row->y
 21282                       + WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w));
 21283 
 21284       /* Display lines beginning with first_row_to_display in the
 21285          desired matrix.  Set last_text_row to the last row displayed
 21286          that displays text.  */
 21287       it.glyph_row = MATRIX_ROW (w->desired_matrix, it.vpos);
 21288       if (pt_row == NULL)
 21289         w->cursor.vpos = -1;
 21290       last_text_row = NULL;
 21291       while (it.current_y < it.last_visible_y && !f->fonts_changed)
 21292         if (display_line (&it, w->cursor.vpos))
 21293           last_text_row = it.glyph_row - 1;
 21294 
 21295       /* If point is in a reused row, adjust y and vpos of the cursor
 21296          position.  */
 21297       if (pt_row)
 21298         {
 21299           w->cursor.vpos -= nrows_scrolled;
 21300           w->cursor.y -= first_reusable_row->y - start_row->y;
 21301         }
 21302 
 21303       /* Give up if point isn't in a row displayed or reused.  (This
 21304          also handles the case where w->cursor.vpos < nrows_scrolled
 21305          after the calls to display_line, which can happen with scroll
 21306          margins.  See bug#1295.)  */
 21307       if (w->cursor.vpos < 0)
 21308         {
 21309           clear_glyph_matrix (w->desired_matrix);
 21310           return false;
 21311         }
 21312 
 21313       /* Scroll the display.  */
 21314       run.current_y = first_reusable_row->y;
 21315       run.desired_y = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
 21316       run.height = it.last_visible_y - run.current_y;
 21317       dy = run.current_y - run.desired_y;
 21318 
 21319       if (run.height)
 21320         {
 21321 #ifdef HAVE_WINDOW_SYSTEM
 21322           update_begin (f);
 21323           gui_update_window_begin (w);
 21324           FRAME_RIF (f)->clear_window_mouse_face (w);
 21325           FRAME_RIF (f)->scroll_run_hook (w, &run);
 21326           gui_update_window_end (w, false, false);
 21327           update_end (f);
 21328 #endif
 21329         }
 21330 
 21331       /* Adjust Y positions of reused rows.  */
 21332       bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
 21333       min_y = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
 21334       max_y = it.last_visible_y;
 21335       for (row = first_reusable_row; row < first_row_to_display; ++row)
 21336         {
 21337           row->y -= dy;
 21338           row->visible_height = row->height;
 21339           if (row->y < min_y)
 21340             row->visible_height -= min_y - row->y;
 21341           if (row->y + row->height > max_y)
 21342             row->visible_height -= row->y + row->height - max_y;
 21343           if (row->fringe_bitmap_periodic_p)
 21344             row->redraw_fringe_bitmaps_p = true;
 21345         }
 21346 
 21347       /* Scroll the current matrix.  */
 21348       eassert (nrows_scrolled > 0);
 21349       rotate_matrix (w->current_matrix,
 21350                      start_vpos,
 21351                      MATRIX_ROW_VPOS (bottom_row, w->current_matrix),
 21352                      -nrows_scrolled);
 21353 
 21354       /* Disable rows not reused.  */
 21355       for (row -= nrows_scrolled; row < bottom_row; ++row)
 21356         row->enabled_p = false;
 21357 
 21358       /* Point may have moved to a different line, so we cannot assume that
 21359          the previous cursor position is valid; locate the correct row.  */
 21360       if (pt_row)
 21361         {
 21362           for (row = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
 21363                row < bottom_row
 21364                  && PT >= MATRIX_ROW_END_CHARPOS (row)
 21365                  && !row->ends_at_zv_p;
 21366                row++)
 21367             {
 21368               w->cursor.vpos++;
 21369               w->cursor.y = row->y;
 21370             }
 21371           if (row < bottom_row)
 21372             {
 21373               /* Can't simply scan the row for point with
 21374                  bidi-reordered glyph rows.  Let set_cursor_from_row
 21375                  figure out where to put the cursor, and if it fails,
 21376                  give up.  */
 21377               if (!NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering)))
 21378                 {
 21379                   if (!set_cursor_from_row (w, row, w->current_matrix,
 21380                                             0, 0, 0, 0))
 21381                     {
 21382                       clear_glyph_matrix (w->desired_matrix);
 21383                       return false;
 21384                     }
 21385                 }
 21386               else
 21387                 {
 21388                   struct glyph *glyph = row->glyphs[TEXT_AREA] + w->cursor.hpos;
 21389                   struct glyph *end = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
 21390 
 21391                   for (; glyph < end
 21392                          && (!BUFFERP (glyph->object)
 21393                              || glyph->charpos < PT);
 21394                        glyph++)
 21395                     {
 21396                       w->cursor.hpos++;
 21397                       w->cursor.x += glyph->pixel_width;
 21398                     }
 21399                 }
 21400             }
 21401         }
 21402 
 21403       /* Adjust window end.  A null value of last_text_row means that
 21404          the window end is in reused rows which in turn means that
 21405          only its vpos can have changed.  */
 21406       if (last_text_row)
 21407         adjust_window_ends (w, last_text_row, false);
 21408       else
 21409         w->window_end_vpos -= nrows_scrolled;
 21410 
 21411       w->window_end_valid = false;
 21412       w->desired_matrix->no_scrolling_p = true;
 21413 
 21414 #ifdef GLYPH_DEBUG
 21415       debug_method_add (w, "try_window_reusing_current_matrix 2");
 21416 #endif
 21417       return true;
 21418     }
 21419 
 21420   return false;
 21421 }
 21422 
 21423 
 21424 
 21425 /************************************************************************
 21426    Window redisplay reusing current matrix when buffer has changed
 21427  ************************************************************************/
 21428 
 21429 static struct glyph_row *find_last_unchanged_at_beg_row (struct window *);
 21430 static struct glyph_row *find_first_unchanged_at_end_row (struct window *,
 21431                                                           ptrdiff_t *, ptrdiff_t *);
 21432 static struct glyph_row *
 21433 find_last_row_displaying_text (struct glyph_matrix *, struct it *,
 21434                                struct glyph_row *);
 21435 
 21436 
 21437 /* Return the last row in MATRIX displaying text.  If row START is
 21438    non-null, start searching with that row.  IT gives the dimensions
 21439    of the display.  Value is null if matrix is empty; otherwise it is
 21440    a pointer to the row found.  */
 21441 
 21442 static struct glyph_row *
 21443 find_last_row_displaying_text (struct glyph_matrix *matrix, struct it *it,
 21444                                struct glyph_row *start)
 21445 {
 21446   struct glyph_row *row, *row_found;
 21447 
 21448   /* Set row_found to the last row in IT->w's current matrix
 21449      displaying text.  The loop looks funny but think of partially
 21450      visible lines.  */
 21451   row_found = NULL;
 21452   row = start ? start : MATRIX_FIRST_TEXT_ROW (matrix);
 21453   while (MATRIX_ROW_DISPLAYS_TEXT_P (row))
 21454     {
 21455       eassert (row->enabled_p);
 21456       row_found = row;
 21457       if (MATRIX_ROW_BOTTOM_Y (row) >= it->last_visible_y)
 21458         break;
 21459       ++row;
 21460     }
 21461 
 21462   return row_found;
 21463 }
 21464 
 21465 
 21466 /* Return the last row in the current matrix of W that is not affected
 21467    by changes at the start of current_buffer that occurred since W's
 21468    current matrix was built.  Value is null if no such row exists.
 21469 
 21470    BEG_UNCHANGED is the number of characters unchanged at the start of
 21471    current_buffer.  BEG + BEG_UNCHANGED is the buffer position of the
 21472    first changed character in current_buffer.  Characters at positions <
 21473    BEG + BEG_UNCHANGED are at the same buffer positions as they were
 21474    when the current matrix was built.  */
 21475 
 21476 static struct glyph_row *
 21477 find_last_unchanged_at_beg_row (struct window *w)
 21478 {
 21479   ptrdiff_t first_changed_pos = BEG + BEG_UNCHANGED;
 21480   struct glyph_row *row;
 21481   struct glyph_row *row_found = NULL;
 21482   int yb = window_text_bottom_y (w);
 21483 
 21484   /* Find the last row displaying unchanged text.  */
 21485   for (row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 21486        MATRIX_ROW_DISPLAYS_TEXT_P (row)
 21487          && MATRIX_ROW_START_CHARPOS (row) < first_changed_pos;
 21488        ++row)
 21489     {
 21490       if (/* If row ends before first_changed_pos, it is unchanged,
 21491              except in some case.  */
 21492           MATRIX_ROW_END_CHARPOS (row) <= first_changed_pos
 21493           /* When row ends in ZV and we write at ZV it is not
 21494              unchanged.  */
 21495           && !row->ends_at_zv_p
 21496           /* When first_changed_pos is the end of a continued line,
 21497              row is not unchanged because it may be no longer
 21498              continued.  */
 21499           && !(MATRIX_ROW_END_CHARPOS (row) == first_changed_pos
 21500                && (row->continued_p
 21501                    || row->exact_window_width_line_p))
 21502           /* If ROW->end is beyond ZV, then ROW->end is outdated and
 21503              needs to be recomputed, so don't consider this row as
 21504              unchanged.  This happens when the last line was
 21505              bidi-reordered and was killed immediately before this
 21506              redisplay cycle.  In that case, ROW->end stores the
 21507              buffer position of the first visual-order character of
 21508              the killed text, which is now beyond ZV.  */
 21509           && CHARPOS (row->end.pos) <= ZV)
 21510         row_found = row;
 21511 
 21512       /* Stop if last visible row.  */
 21513       if (MATRIX_ROW_BOTTOM_Y (row) >= yb)
 21514         break;
 21515     }
 21516 
 21517   return row_found;
 21518 }
 21519 
 21520 
 21521 /* Find the first glyph row in the current matrix of W that is not
 21522    affected by changes at the end of current_buffer since the
 21523    time W's current matrix was built.
 21524 
 21525    Return in *DELTA the number of chars by which buffer positions in
 21526    unchanged text at the end of current_buffer must be adjusted.
 21527 
 21528    Return in *DELTA_BYTES the corresponding number of bytes.
 21529 
 21530    Value is null if no such row exists, i.e. all rows are affected by
 21531    changes.  */
 21532 
 21533 static struct glyph_row *
 21534 find_first_unchanged_at_end_row (struct window *w,
 21535                                  ptrdiff_t *delta, ptrdiff_t *delta_bytes)
 21536 {
 21537   struct glyph_row *row;
 21538   struct glyph_row *row_found = NULL;
 21539 
 21540   *delta = *delta_bytes = 0;
 21541 
 21542   /* Display must not have been paused, otherwise the current matrix
 21543      is not up to date.  */
 21544   eassert (w->window_end_valid);
 21545 
 21546   /* A value of window_end_pos >= END_UNCHANGED means that the window
 21547      end is in the range of changed text.  If so, there is no
 21548      unchanged row at the end of W's current matrix.  */
 21549   if (w->window_end_pos >= END_UNCHANGED)
 21550     return NULL;
 21551 
 21552   /* Set row to the last row in W's current matrix displaying text.  */
 21553   row = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
 21554 
 21555   /* If matrix is entirely empty, no unchanged row exists.  */
 21556   if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
 21557     {
 21558       /* The value of row is the last glyph row in the matrix having a
 21559          meaningful buffer position in it.  The end position of row
 21560          corresponds to window_end_pos.  This allows us to translate
 21561          buffer positions in the current matrix to current buffer
 21562          positions for characters not in changed text.  */
 21563       ptrdiff_t Z_old =
 21564         MATRIX_ROW_END_CHARPOS (row) + w->window_end_pos;
 21565       ptrdiff_t Z_BYTE_old =
 21566         MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
 21567       ptrdiff_t last_unchanged_pos, last_unchanged_pos_old;
 21568       struct glyph_row *first_text_row
 21569         = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 21570 
 21571       *delta = Z - Z_old;
 21572       *delta_bytes = Z_BYTE - Z_BYTE_old;
 21573 
 21574       /* Set last_unchanged_pos to the buffer position of the last
 21575          character in the buffer that has not been changed.  Z is the
 21576          index + 1 of the last character in current_buffer, i.e. by
 21577          subtracting END_UNCHANGED we get the index of the last
 21578          unchanged character, and we have to add BEG to get its buffer
 21579          position.  */
 21580       last_unchanged_pos = Z - END_UNCHANGED + BEG;
 21581       last_unchanged_pos_old = last_unchanged_pos - *delta;
 21582 
 21583       /* Search backward from ROW for a row displaying a line that
 21584          starts at a minimum position >= last_unchanged_pos_old.  */
 21585       for (; row > first_text_row; --row)
 21586         {
 21587           /* This used to abort, but it can happen.
 21588              It is ok to just stop the search instead here.  KFS.  */
 21589           if (!row->enabled_p || !MATRIX_ROW_DISPLAYS_TEXT_P (row))
 21590             break;
 21591 
 21592           if (MATRIX_ROW_START_CHARPOS (row) >= last_unchanged_pos_old)
 21593             row_found = row;
 21594         }
 21595     }
 21596 
 21597   eassert (!row_found || MATRIX_ROW_DISPLAYS_TEXT_P (row_found));
 21598 
 21599   return row_found;
 21600 }
 21601 
 21602 
 21603 /* Make sure that glyph rows in the current matrix of window W
 21604    reference the same glyph memory as corresponding rows in the
 21605    frame's frame matrix.  This function is called after scrolling W's
 21606    current matrix on a terminal frame in try_window_id and
 21607    try_window_reusing_current_matrix.  */
 21608 
 21609 static void
 21610 sync_frame_with_window_matrix_rows (struct window *w)
 21611 {
 21612   struct frame *f = XFRAME (w->frame);
 21613   struct glyph_row *window_row, *window_row_end, *frame_row;
 21614 
 21615   /* Preconditions: W must be a leaf window and full-width.  Its frame
 21616      must have a frame matrix.  */
 21617   eassert (BUFFERP (w->contents));
 21618   eassert (WINDOW_FULL_WIDTH_P (w));
 21619   eassert (!FRAME_WINDOW_P (f));
 21620 
 21621   /* If W is a full-width window, glyph pointers in W's current matrix
 21622      have, by definition, to be the same as glyph pointers in the
 21623      corresponding frame matrix.  Note that frame matrices have no
 21624      marginal areas (see build_frame_matrix).  */
 21625   window_row = w->current_matrix->rows;
 21626   window_row_end = window_row + w->current_matrix->nrows;
 21627   frame_row = f->current_matrix->rows + WINDOW_TOP_EDGE_LINE (w);
 21628   while (window_row < window_row_end)
 21629     {
 21630       struct glyph *start = window_row->glyphs[LEFT_MARGIN_AREA];
 21631       struct glyph *end = window_row->glyphs[LAST_AREA];
 21632 
 21633       frame_row->glyphs[LEFT_MARGIN_AREA] = start;
 21634       frame_row->glyphs[TEXT_AREA] = start;
 21635       frame_row->glyphs[RIGHT_MARGIN_AREA] = end;
 21636       frame_row->glyphs[LAST_AREA] = end;
 21637 
 21638       /* Disable frame rows whose corresponding window rows have
 21639          been disabled in try_window_id.  */
 21640       if (!window_row->enabled_p)
 21641         frame_row->enabled_p = false;
 21642 
 21643       ++window_row, ++frame_row;
 21644     }
 21645 }
 21646 
 21647 
 21648 /* Find the glyph row in window W containing CHARPOS.  Consider all
 21649    rows between START and END (not inclusive).  END null means search
 21650    all rows to the end of the display area of W.  Value is the row
 21651    containing CHARPOS or null.  */
 21652 
 21653 struct glyph_row *
 21654 row_containing_pos (struct window *w, ptrdiff_t charpos,
 21655                     struct glyph_row *start, struct glyph_row *end, int dy)
 21656 {
 21657   struct glyph_row *row = start;
 21658   struct glyph_row *best_row = NULL;
 21659   ptrdiff_t mindif = BUF_ZV (XBUFFER (w->contents)) + 1;
 21660   int last_y;
 21661 
 21662   /* If we happen to start on a header-line or a tab-line, skip that.  */
 21663   if (row->tab_line_p)
 21664     ++row;
 21665   if (row->mode_line_p)
 21666     ++row;
 21667 
 21668   if ((end && row >= end) || !row->enabled_p)
 21669     return NULL;
 21670 
 21671   last_y = window_text_bottom_y (w) - dy;
 21672 
 21673   while (true)
 21674     {
 21675       /* Give up if we have gone too far.  */
 21676       if ((end && row >= end) || !row->enabled_p)
 21677         return NULL;
 21678       /* This formerly returned if they were equal.
 21679          I think that both quantities are of a "last plus one" type;
 21680          if so, when they are equal, the row is within the screen. -- rms.  */
 21681       if (MATRIX_ROW_BOTTOM_Y (row) > last_y)
 21682         return NULL;
 21683 
 21684       /* If it is in this row, return this row.  */
 21685       if (! (MATRIX_ROW_END_CHARPOS (row) < charpos
 21686              || (MATRIX_ROW_END_CHARPOS (row) == charpos
 21687                  /* The end position of a row equals the start
 21688                     position of the next row.  If CHARPOS is there, we
 21689                     would rather consider it displayed in the next
 21690                     line, except when this line ends in ZV.  */
 21691                  && !row_for_charpos_p (row, charpos)))
 21692           && charpos >= MATRIX_ROW_START_CHARPOS (row))
 21693         {
 21694           struct glyph *g;
 21695 
 21696           if (NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering))
 21697               || (!best_row && !row->continued_p))
 21698             return row;
 21699           /* In bidi-reordered rows, there could be several rows whose
 21700              edges surround CHARPOS, all of these rows belonging to
 21701              the same continued line.  We need to find the row which
 21702              fits CHARPOS the best.  */
 21703           for (g = row->glyphs[TEXT_AREA];
 21704                g < row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
 21705                g++)
 21706             {
 21707               if (!STRINGP (g->object))
 21708                 {
 21709                   if (g->charpos > 0 && eabs (g->charpos - charpos) < mindif)
 21710                     {
 21711                       mindif = eabs (g->charpos - charpos);
 21712                       best_row = row;
 21713                       /* Exact match always wins.  */
 21714                       if (mindif == 0)
 21715                         return best_row;
 21716                     }
 21717                 }
 21718             }
 21719         }
 21720       else if (best_row && !row->continued_p)
 21721         return best_row;
 21722       ++row;
 21723     }
 21724 }
 21725 
 21726 
 21727 /* Try to redisplay window W by reusing its existing display.  W's
 21728    current matrix must be up to date when this function is called,
 21729    i.e., window_end_valid must be true.
 21730 
 21731    Value is
 21732 
 21733    >= 1 if successful, i.e. display has been updated
 21734          specifically:
 21735          1 means the changes were in front of a newline that precedes
 21736            the window start, and the whole current matrix was reused
 21737          2 means the changes were after the last position displayed
 21738            in the window, and the whole current matrix was reused
 21739          3 means portions of the current matrix were reused, while
 21740            some of the screen lines were redrawn
 21741    -1   if redisplay with same window start is known not to succeed
 21742    0    if otherwise unsuccessful
 21743 
 21744    The following steps are performed:
 21745 
 21746    1. Find the last row in the current matrix of W that is not
 21747    affected by changes at the start of current_buffer.  If no such row
 21748    is found, give up.
 21749 
 21750    2. Find the first row in W's current matrix that is not affected by
 21751    changes at the end of current_buffer.  Maybe there is no such row.
 21752 
 21753    3. Display lines beginning with the row + 1 found in step 1 to the
 21754    row found in step 2 or, if step 2 didn't find a row, to the end of
 21755    the window.
 21756 
 21757    4. If cursor is not known to appear on the window, give up.
 21758 
 21759    5. If display stopped at the row found in step 2, scroll the
 21760    display and current matrix as needed.
 21761 
 21762    6. Maybe display some lines at the end of W, if we must.  This can
 21763    happen under various circumstances, like a partially visible line
 21764    becoming fully visible, or because newly displayed lines are displayed
 21765    in smaller font sizes.
 21766 
 21767    7. Update W's window end information.  */
 21768 
 21769 static int
 21770 try_window_id (struct window *w)
 21771 {
 21772   struct frame *f = XFRAME (w->frame);
 21773   struct glyph_matrix *current_matrix = w->current_matrix;
 21774   struct glyph_matrix *desired_matrix = w->desired_matrix;
 21775   struct glyph_row *last_unchanged_at_beg_row;
 21776   struct glyph_row *first_unchanged_at_end_row;
 21777   struct glyph_row *row;
 21778   struct glyph_row *bottom_row;
 21779   int bottom_vpos;
 21780   struct it it;
 21781   ptrdiff_t delta = 0, delta_bytes = 0, stop_pos;
 21782   int dvpos, dy;
 21783   struct text_pos start_pos;
 21784   struct run run;
 21785   int first_unchanged_at_end_vpos = 0;
 21786   struct glyph_row *last_text_row, *last_text_row_at_end;
 21787   struct text_pos start;
 21788   ptrdiff_t first_changed_charpos, last_changed_charpos;
 21789 
 21790 #ifdef GLYPH_DEBUG
 21791   if (inhibit_try_window_id)
 21792     return 0;
 21793 #endif
 21794 
 21795   /* This is handy for debugging.  */
 21796 #if false
 21797 #define GIVE_UP(X)                                              \
 21798   do {                                                          \
 21799     redisplay_trace ("try_window_id give up %d\n", X);          \
 21800     return 0;                                                   \
 21801   } while (false)
 21802 #else
 21803 #define GIVE_UP(X) return 0
 21804 #endif
 21805 
 21806   SET_TEXT_POS_FROM_MARKER (start, w->start);
 21807 
 21808   /* Don't use this for mini-windows because these can show
 21809      messages and mini-buffers, and we don't handle that here.  */
 21810   if (MINI_WINDOW_P (w))
 21811     GIVE_UP (1);
 21812 
 21813   /* This flag is used to prevent redisplay optimizations.  */
 21814   if (windows_or_buffers_changed || f->cursor_type_changed)
 21815     GIVE_UP (2);
 21816 
 21817   /* This function's optimizations cannot be used if overlays have
 21818      changed in the buffer displayed by the window, so give up if they
 21819      have.  */
 21820   if (w->last_overlay_modified != OVERLAY_MODIFF)
 21821     GIVE_UP (200);
 21822 
 21823   /* Verify that narrowing has not changed.
 21824      Also verify that we were not told to prevent redisplay optimizations.
 21825      It would be nice to further
 21826      reduce the number of cases where this prevents try_window_id.  */
 21827   if (current_buffer->clip_changed
 21828       || current_buffer->prevent_redisplay_optimizations_p)
 21829     GIVE_UP (3);
 21830 
 21831   /* Window must either use window-based redisplay or be full width.  */
 21832   if (!FRAME_WINDOW_P (f)
 21833       && (!FRAME_LINE_INS_DEL_OK (f)
 21834           || !WINDOW_FULL_WIDTH_P (w)))
 21835     GIVE_UP (4);
 21836 
 21837   /* Give up if point is known NOT to appear in W.  */
 21838   if (PT < CHARPOS (start))
 21839     GIVE_UP (5);
 21840 
 21841   /* Another way to prevent redisplay optimizations.  */
 21842   if (w->last_modified == 0)
 21843     GIVE_UP (6);
 21844 
 21845   /* Verify that window is not hscrolled.  */
 21846   if (w->hscroll != 0)
 21847     GIVE_UP (7);
 21848 
 21849   /* Verify that display wasn't paused.  */
 21850   if (!w->window_end_valid)
 21851     GIVE_UP (8);
 21852 
 21853   /* Likewise if highlighting trailing whitespace.  */
 21854   if (!NILP (Vshow_trailing_whitespace))
 21855     GIVE_UP (11);
 21856 
 21857   /* Can't use this if overlay arrow position and/or string have
 21858      changed.  */
 21859   if (overlay_arrows_changed_p (false))
 21860     GIVE_UP (12);
 21861 
 21862   /* When word-wrap is on, adding a space to the first word of a
 21863      wrapped line can change the wrap position, altering the line
 21864      above it.  It might be worthwhile to handle this more
 21865      intelligently, but for now just redisplay from scratch.  */
 21866   if (!NILP (BVAR (XBUFFER (w->contents), word_wrap)))
 21867     GIVE_UP (21);
 21868 
 21869   /* Under bidi reordering, adding or deleting a character in the
 21870      beginning of a paragraph, before the first strong directional
 21871      character, can change the base direction of the paragraph (unless
 21872      the buffer specifies a fixed paragraph direction), which will
 21873      require redisplaying the whole paragraph.  It might be worthwhile
 21874      to find the paragraph limits and widen the range of redisplayed
 21875      lines to that, but for now just give up this optimization and
 21876      redisplay from scratch.  */
 21877   if (!NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering))
 21878       && NILP (BVAR (XBUFFER (w->contents), bidi_paragraph_direction)))
 21879     GIVE_UP (22);
 21880 
 21881   /* Give up if the buffer has line-spacing set, as Lisp-level changes
 21882      to that variable require thorough redisplay.  */
 21883   if (!NILP (BVAR (XBUFFER (w->contents), extra_line_spacing)))
 21884     GIVE_UP (23);
 21885 
 21886   /* Give up if display-line-numbers is in relative mode, or when the
 21887      current line's number needs to be displayed in a distinct face.  */
 21888   if (EQ (Vdisplay_line_numbers, Qrelative)
 21889       || EQ (Vdisplay_line_numbers, Qvisual)
 21890       || (!NILP (Vdisplay_line_numbers)
 21891           && NILP (Finternal_lisp_face_equal_p (Qline_number,
 21892                                                 Qline_number_current_line,
 21893                                                 w->frame))))
 21894     GIVE_UP (24);
 21895 
 21896   /* composition-break-at-point is incompatible with the optimizations
 21897      in this function, because we need to recompose characters when
 21898      point moves off their positions.  */
 21899   if (composition_break_at_point)
 21900     GIVE_UP (27);
 21901 
 21902   /* Make sure beg_unchanged and end_unchanged are up to date.  Do it
 21903      only if buffer has really changed.  The reason is that the gap is
 21904      initially at Z for freshly visited files.  The code below would
 21905      set end_unchanged to 0 in that case.  */
 21906   if (MODIFF > SAVE_MODIFF
 21907       /* This seems to happen sometimes after saving a buffer.  */
 21908       || BEG_UNCHANGED + END_UNCHANGED > Z_BYTE)
 21909     {
 21910       if (GPT - BEG < BEG_UNCHANGED)
 21911         BEG_UNCHANGED = GPT - BEG;
 21912       if (Z - GPT < END_UNCHANGED)
 21913         END_UNCHANGED = Z - GPT;
 21914     }
 21915 
 21916   /* The position of the first and last character that has been changed.  */
 21917   first_changed_charpos = BEG + BEG_UNCHANGED;
 21918   last_changed_charpos  = Z - END_UNCHANGED;
 21919 
 21920   /* If window starts after a line end, and the last change is in
 21921      front of that newline, then changes don't affect the display.
 21922      This case happens with stealth-fontification.  Note that although
 21923      the display is unchanged, glyph positions in the matrix have to
 21924      be adjusted, of course.  */
 21925   row = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
 21926   if (MATRIX_ROW_DISPLAYS_TEXT_P (row)
 21927       && ((last_changed_charpos < CHARPOS (start)
 21928            && CHARPOS (start) == BEGV)
 21929           || (last_changed_charpos < CHARPOS (start) - 1
 21930               && FETCH_BYTE (BYTEPOS (start) - 1) == '\n')))
 21931     {
 21932       ptrdiff_t Z_old, Z_delta, Z_BYTE_old, Z_delta_bytes;
 21933       struct glyph_row *r0;
 21934 
 21935       /* Compute how many chars/bytes have been added to or removed
 21936          from the buffer.  */
 21937       Z_old = MATRIX_ROW_END_CHARPOS (row) + w->window_end_pos;
 21938       Z_BYTE_old = MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
 21939       Z_delta = Z - Z_old;
 21940       Z_delta_bytes = Z_BYTE - Z_BYTE_old;
 21941 
 21942       /* Give up if PT is not in the window.  Note that it already has
 21943          been checked at the start of try_window_id that PT is not in
 21944          front of the window start.  */
 21945       if (PT >= MATRIX_ROW_END_CHARPOS (row) + Z_delta)
 21946         GIVE_UP (13);
 21947 
 21948       /* If window start is unchanged, we can reuse the whole matrix
 21949          as is, after adjusting glyph positions.  No need to compute
 21950          the window end again, since its offset from Z hasn't changed.  */
 21951       r0 = MATRIX_FIRST_TEXT_ROW (current_matrix);
 21952       if (CHARPOS (start) == MATRIX_ROW_START_CHARPOS (r0) + Z_delta
 21953           && BYTEPOS (start) == MATRIX_ROW_START_BYTEPOS (r0) + Z_delta_bytes
 21954           /* PT must not be in a partially visible line.  */
 21955           && !(PT >= MATRIX_ROW_START_CHARPOS (row) + Z_delta
 21956                && MATRIX_ROW_BOTTOM_Y (row) > window_text_bottom_y (w)))
 21957         {
 21958           /* Adjust positions in the glyph matrix.  */
 21959           if (Z_delta || Z_delta_bytes)
 21960             {
 21961               struct glyph_row *r1
 21962                 = MATRIX_BOTTOM_TEXT_ROW (current_matrix, w);
 21963               increment_matrix_positions (w->current_matrix,
 21964                                           MATRIX_ROW_VPOS (r0, current_matrix),
 21965                                           MATRIX_ROW_VPOS (r1, current_matrix),
 21966                                           Z_delta, Z_delta_bytes);
 21967             }
 21968 
 21969           /* Set the cursor.  */
 21970           row = row_containing_pos (w, PT, r0, NULL, 0);
 21971           if (row)
 21972             set_cursor_from_row (w, row, current_matrix, 0, 0, 0, 0);
 21973           return 1;
 21974         }
 21975     }
 21976 
 21977   /* Handle the case that changes are all below what is displayed in
 21978      the window, and that PT is in the window.  This shortcut cannot
 21979      be taken if ZV is visible in the window, and text has been added
 21980      there that is visible in the window.  */
 21981   if (first_changed_charpos >= MATRIX_ROW_END_CHARPOS (row)
 21982       /* ZV is not visible in the window, or there are no
 21983          changes at ZV, actually.  */
 21984       && (current_matrix->zv > MATRIX_ROW_END_CHARPOS (row)
 21985           || first_changed_charpos == last_changed_charpos))
 21986     {
 21987       struct glyph_row *r0;
 21988 
 21989       /* Give up if PT is not in the window.  Note that it already has
 21990          been checked at the start of try_window_id that PT is not in
 21991          front of the window start.  */
 21992       if (PT >= MATRIX_ROW_END_CHARPOS (row))
 21993         GIVE_UP (14);
 21994 
 21995       /* If window start is unchanged, we can reuse the whole matrix
 21996          as is, without changing glyph positions since no text has
 21997          been added/removed in front of the window end.  */
 21998       r0 = MATRIX_FIRST_TEXT_ROW (current_matrix);
 21999       if (TEXT_POS_EQUAL_P (start, r0->minpos)
 22000           /* PT must not be in a partially visible line.  */
 22001           && !(PT >= MATRIX_ROW_START_CHARPOS (row)
 22002                && MATRIX_ROW_BOTTOM_Y (row) > window_text_bottom_y (w)))
 22003         {
 22004           /* We have to compute the window end anew since text
 22005              could have been added/removed after it.  */
 22006           w->window_end_pos = Z - MATRIX_ROW_END_CHARPOS (row);
 22007           w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
 22008 
 22009           /* Set the cursor.  */
 22010           row = row_containing_pos (w, PT, r0, NULL, 0);
 22011           if (row)
 22012             set_cursor_from_row (w, row, current_matrix, 0, 0, 0, 0);
 22013           return 2;
 22014         }
 22015     }
 22016 
 22017   /* Give up if window start is in the changed area.
 22018 
 22019      The condition used to read
 22020 
 22021      (BEG_UNCHANGED + END_UNCHANGED != Z - BEG && ...)
 22022 
 22023      but why that was tested escapes me at the moment.  */
 22024   if (CHARPOS (start) >= first_changed_charpos
 22025       && CHARPOS (start) <= last_changed_charpos)
 22026     GIVE_UP (15);
 22027 
 22028   /* Check that window start agrees with the start of the first glyph
 22029      row in its current matrix.  Check this after we know the window
 22030      start is not in changed text, otherwise positions would not be
 22031      comparable.  */
 22032   row = MATRIX_FIRST_TEXT_ROW (current_matrix);
 22033   if (!TEXT_POS_EQUAL_P (start, row->minpos))
 22034     GIVE_UP (16);
 22035 
 22036   /* Give up if the window ends in strings.  Overlay strings
 22037      at the end are difficult to handle, so don't try.  */
 22038   row = MATRIX_ROW (current_matrix, w->window_end_vpos);
 22039   if (MATRIX_ROW_START_CHARPOS (row) == MATRIX_ROW_END_CHARPOS (row))
 22040     GIVE_UP (20);
 22041 
 22042   /* Can't let scroll_run_hook below run on w32 GUI frames when
 22043      position of point is indicated by the system caret, because
 22044      scrolling the display will then "copy" the pixels used by the
 22045      caret.  */
 22046 #ifdef HAVE_NTGUI
 22047   if (FRAME_W32_P (f) && w32_use_visible_system_caret)
 22048     GIVE_UP (25);
 22049 #endif
 22050 
 22051   /* Compute the position at which we have to start displaying new
 22052      lines.  Some of the lines at the top of the window might be
 22053      reusable because they are not displaying changed text.  Find the
 22054      last row in W's current matrix not affected by changes at the
 22055      start of current_buffer.  Value is null if changes start in the
 22056      first line of window.  */
 22057   last_unchanged_at_beg_row = find_last_unchanged_at_beg_row (w);
 22058   if (last_unchanged_at_beg_row)
 22059     {
 22060       /* Avoid starting to display in the middle of a character, a TAB
 22061          for instance.  This is easier than to set up the iterator
 22062          exactly, and it's not a frequent case, so the additional
 22063          effort wouldn't really pay off.  */
 22064       while ((MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row)
 22065               || last_unchanged_at_beg_row->ends_in_newline_from_string_p)
 22066              && last_unchanged_at_beg_row > w->current_matrix->rows)
 22067         --last_unchanged_at_beg_row;
 22068 
 22069       if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row))
 22070         GIVE_UP (17);
 22071 
 22072       if (! init_to_row_end (&it, w, last_unchanged_at_beg_row))
 22073         GIVE_UP (18);
 22074       /* Give up if the row starts with a display property that draws
 22075          on the fringes, since that could prevent correct display of
 22076          line-prefix and wrap-prefix.  */
 22077       if (it.sp > 1
 22078           && it.method == GET_FROM_IMAGE && it.image_id == -1)
 22079         GIVE_UP (26);
 22080       start_pos = it.current.pos;
 22081 
 22082       /* Start displaying new lines in the desired matrix at the same
 22083          vpos we would use in the current matrix, i.e. below
 22084          last_unchanged_at_beg_row.  */
 22085       it.vpos = 1 + MATRIX_ROW_VPOS (last_unchanged_at_beg_row,
 22086                                      current_matrix);
 22087       it.glyph_row = MATRIX_ROW (desired_matrix, it.vpos);
 22088       it.current_y = MATRIX_ROW_BOTTOM_Y (last_unchanged_at_beg_row);
 22089 
 22090       eassert (it.hpos == 0 && it.current_x == 0);
 22091     }
 22092   else
 22093     {
 22094       /* There are no reusable lines at the start of the window.
 22095          Start displaying in the first text line.  */
 22096       start_display (&it, w, start);
 22097       it.vpos = it.first_vpos;
 22098       start_pos = it.current.pos;
 22099     }
 22100 
 22101   /* Find the first row that is not affected by changes at the end of
 22102      the buffer.  Value will be null if there is no unchanged row, in
 22103      which case we must redisplay to the end of the window.  delta
 22104      will be set to the value by which buffer positions beginning with
 22105      first_unchanged_at_end_row have to be adjusted due to text
 22106      changes.  */
 22107   first_unchanged_at_end_row
 22108     = find_first_unchanged_at_end_row (w, &delta, &delta_bytes);
 22109   IF_DEBUG (debug_delta = delta);
 22110   IF_DEBUG (debug_delta_bytes = delta_bytes);
 22111 
 22112   /* Set stop_pos to the buffer position up to which we will have to
 22113      display new lines.  If first_unchanged_at_end_row != NULL, this
 22114      is the buffer position of the start of the line displayed in that
 22115      row.  For first_unchanged_at_end_row == NULL, use 0 to indicate
 22116      that we don't stop at a buffer position.  */
 22117   stop_pos = 0;
 22118   if (first_unchanged_at_end_row)
 22119     {
 22120       eassert (last_unchanged_at_beg_row == NULL
 22121                || first_unchanged_at_end_row >= last_unchanged_at_beg_row);
 22122 
 22123       /* If this is a continuation line, move forward to the next one
 22124          that isn't.  Changes in lines above affect this line.
 22125          Caution: this may move first_unchanged_at_end_row to a row
 22126          not displaying text.  */
 22127       while (MATRIX_ROW_CONTINUATION_LINE_P (first_unchanged_at_end_row)
 22128              && MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row)
 22129              && (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row)
 22130                  < it.last_visible_y))
 22131         ++first_unchanged_at_end_row;
 22132 
 22133       if (!MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row)
 22134           || (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row)
 22135               >= it.last_visible_y))
 22136         first_unchanged_at_end_row = NULL;
 22137       else
 22138         {
 22139           stop_pos = (MATRIX_ROW_START_CHARPOS (first_unchanged_at_end_row)
 22140                       + delta);
 22141           first_unchanged_at_end_vpos
 22142             = MATRIX_ROW_VPOS (first_unchanged_at_end_row, current_matrix);
 22143           eassert (stop_pos >= Z - END_UNCHANGED);
 22144         }
 22145     }
 22146   else if (last_unchanged_at_beg_row == NULL)
 22147     GIVE_UP (19);
 22148 
 22149 
 22150 #ifdef GLYPH_DEBUG
 22151 
 22152   /* Either there is no unchanged row at the end, or the one we have
 22153      now displays text.  This is a necessary condition for the window
 22154      end pos calculation at the end of this function.  */
 22155   eassert (first_unchanged_at_end_row == NULL
 22156            || MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row));
 22157 
 22158   debug_last_unchanged_at_beg_vpos
 22159     = (last_unchanged_at_beg_row
 22160        ? MATRIX_ROW_VPOS (last_unchanged_at_beg_row, current_matrix)
 22161        : -1);
 22162   debug_first_unchanged_at_end_vpos = first_unchanged_at_end_vpos;
 22163 
 22164 #endif /* GLYPH_DEBUG */
 22165 
 22166 
 22167   /* Display new lines.  Set last_text_row to the last new line
 22168      displayed which has text on it, i.e. might end up as being the
 22169      line where the window_end_vpos is.  */
 22170   w->cursor.vpos = -1;
 22171   last_text_row = NULL;
 22172   overlay_arrow_seen = false;
 22173   if (it.current_y < it.last_visible_y
 22174       && !f->fonts_changed
 22175       && (first_unchanged_at_end_row == NULL
 22176           || IT_CHARPOS (it) < stop_pos))
 22177     it.glyph_row->reversed_p = false;
 22178   while (it.current_y < it.last_visible_y
 22179          && !f->fonts_changed
 22180          && (first_unchanged_at_end_row == NULL
 22181              || IT_CHARPOS (it) < stop_pos))
 22182     {
 22183       if (display_line (&it, -1))
 22184         last_text_row = it.glyph_row - 1;
 22185     }
 22186 
 22187   if (f->fonts_changed)
 22188     return -1;
 22189 
 22190   /* The redisplay iterations in display_line above could have
 22191      triggered font-lock, which could have done something that
 22192      invalidates IT->w window's end-point information, on which we
 22193      rely below.  E.g., one package, which will remain unnamed, used
 22194      to install a font-lock-fontify-region-function that called
 22195      bury-buffer, whose side effect is to switch the buffer displayed
 22196      by IT->w, and that predictably resets IT->w's window_end_valid
 22197      flag, which we already tested at the entry to this function.
 22198      Amply punish such packages/modes by giving up on this
 22199      optimization in those cases.  */
 22200   if (!w->window_end_valid)
 22201     {
 22202       clear_glyph_matrix (w->desired_matrix);
 22203       return -1;
 22204     }
 22205 
 22206   /* Compute differences in buffer positions, y-positions etc.  for
 22207      lines reused at the bottom of the window.  Compute what we can
 22208      scroll.  */
 22209   if (first_unchanged_at_end_row
 22210       /* No lines reused because we displayed everything up to the
 22211          bottom of the window.  */
 22212       && it.current_y < it.last_visible_y)
 22213     {
 22214       dvpos = (it.vpos
 22215                - MATRIX_ROW_VPOS (first_unchanged_at_end_row,
 22216                                   current_matrix));
 22217       dy = it.current_y - first_unchanged_at_end_row->y;
 22218       run.current_y = first_unchanged_at_end_row->y;
 22219       run.desired_y = run.current_y + dy;
 22220       run.height = it.last_visible_y - max (run.current_y, run.desired_y);
 22221     }
 22222   else
 22223     {
 22224       delta = delta_bytes = dvpos = dy
 22225         = run.current_y = run.desired_y = run.height = 0;
 22226       first_unchanged_at_end_row = NULL;
 22227     }
 22228   IF_DEBUG ((debug_dvpos = dvpos, debug_dy = dy));
 22229 
 22230 
 22231   /* Find the cursor if not already found.  We have to decide whether
 22232      PT will appear on this window (it sometimes doesn't, but this is
 22233      not a very frequent case.)  This decision has to be made before
 22234      the current matrix is altered.  A value of cursor.vpos < 0 means
 22235      that PT is either in one of the lines beginning at
 22236      first_unchanged_at_end_row or below the window.  Don't care for
 22237      lines that might be displayed later at the window end; as
 22238      mentioned, this is not a frequent case.  */
 22239   if (w->cursor.vpos < 0)
 22240     {
 22241       /* Cursor in unchanged rows at the top?  */
 22242       if (PT < CHARPOS (start_pos)
 22243           && last_unchanged_at_beg_row)
 22244         {
 22245           row = row_containing_pos (w, PT,
 22246                                     MATRIX_FIRST_TEXT_ROW (w->current_matrix),
 22247                                     last_unchanged_at_beg_row + 1, 0);
 22248           if (row)
 22249             set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
 22250         }
 22251 
 22252       /* Start from first_unchanged_at_end_row looking for PT.  */
 22253       else if (first_unchanged_at_end_row)
 22254         {
 22255           row = row_containing_pos (w, PT - delta,
 22256                                     first_unchanged_at_end_row, NULL, 0);
 22257           if (row)
 22258             set_cursor_from_row (w, row, w->current_matrix, delta,
 22259                                  delta_bytes, dy, dvpos);
 22260         }
 22261 
 22262       /* Give up if cursor was not found.  */
 22263       if (w->cursor.vpos < 0)
 22264         {
 22265           clear_glyph_matrix (w->desired_matrix);
 22266           return -1;
 22267         }
 22268     }
 22269 
 22270   /* Don't let the cursor end in the scroll margins.  */
 22271   {
 22272     int top_scroll_margin = window_scroll_margin (w, MARGIN_IN_PIXELS);
 22273     int bot_scroll_margin = top_scroll_margin;
 22274     int cursor_height = MATRIX_ROW (w->desired_matrix, w->cursor.vpos)->height;
 22275 
 22276     if (window_wants_header_line (w))
 22277       top_scroll_margin += CURRENT_HEADER_LINE_HEIGHT (w);
 22278     if (window_wants_tab_line (w))
 22279       top_scroll_margin += CURRENT_TAB_LINE_HEIGHT (w);
 22280 
 22281     if ((w->cursor.y < top_scroll_margin
 22282          && CHARPOS (start) > BEGV)
 22283         /* Old redisplay didn't take scroll margin into account at the bottom,
 22284            but then global-hl-line-mode doesn't scroll.  KFS 2004-06-14 */
 22285         || (w->cursor.y
 22286             + (cursor_row_fully_visible_p (w, false, true, true)
 22287                ? 1
 22288                : cursor_height + bot_scroll_margin)) > it.last_visible_y)
 22289       {
 22290         w->cursor.vpos = -1;
 22291         clear_glyph_matrix (w->desired_matrix);
 22292         return -1;
 22293       }
 22294   }
 22295 
 22296   /* Scroll the display.  Do it before changing the current matrix so
 22297      that xterm.c doesn't get confused about where the cursor glyph is
 22298      found.  */
 22299   if (dy && run.height)
 22300     {
 22301       update_begin (f);
 22302 
 22303       if (FRAME_WINDOW_P (f))
 22304         {
 22305 #ifdef HAVE_WINDOW_SYSTEM
 22306           gui_update_window_begin (w);
 22307           FRAME_RIF (f)->clear_window_mouse_face (w);
 22308           FRAME_RIF (f)->scroll_run_hook (w, &run);
 22309           gui_update_window_end (w, false, false);
 22310 #endif
 22311         }
 22312       else
 22313         {
 22314           /* Terminal frame.  In this case, dvpos gives the number of
 22315              lines to scroll by; dvpos < 0 means scroll up.  */
 22316           int from_vpos
 22317             = MATRIX_ROW_VPOS (first_unchanged_at_end_row, w->current_matrix);
 22318           int from = WINDOW_TOP_EDGE_LINE (w) + from_vpos;
 22319           int end = (WINDOW_TOP_EDGE_LINE (w)
 22320                      + window_wants_tab_line (w)
 22321                      + window_wants_header_line (w)
 22322                      + window_internal_height (w));
 22323 
 22324           gui_clear_window_mouse_face (w);
 22325 
 22326           /* Perform the operation on the screen.  */
 22327           if (dvpos > 0)
 22328             {
 22329               /* Scroll last_unchanged_at_beg_row to the end of the
 22330                  window down dvpos lines.  */
 22331               set_terminal_window (f, end);
 22332 
 22333               /* On dumb terminals delete dvpos lines at the end
 22334                  before inserting dvpos empty lines.  */
 22335               if (!FRAME_SCROLL_REGION_OK (f))
 22336                 ins_del_lines (f, end - dvpos, -dvpos);
 22337 
 22338               /* Insert dvpos empty lines in front of
 22339                  last_unchanged_at_beg_row.  */
 22340               ins_del_lines (f, from, dvpos);
 22341             }
 22342           else if (dvpos < 0)
 22343             {
 22344               /* Scroll up last_unchanged_at_beg_vpos to the end of
 22345                  the window to last_unchanged_at_beg_vpos - |dvpos|.  */
 22346               set_terminal_window (f, end);
 22347 
 22348               /* Delete dvpos lines in front of
 22349                  last_unchanged_at_beg_vpos.  ins_del_lines will set
 22350                  the cursor to the given vpos and emit |dvpos| delete
 22351                  line sequences.  */
 22352               ins_del_lines (f, from + dvpos, dvpos);
 22353 
 22354               /* On a dumb terminal insert dvpos empty lines at the
 22355                  end.  */
 22356               if (!FRAME_SCROLL_REGION_OK (f))
 22357                 ins_del_lines (f, end + dvpos, -dvpos);
 22358             }
 22359 
 22360           set_terminal_window (f, 0);
 22361         }
 22362 
 22363       update_end (f);
 22364     }
 22365 
 22366   /* Shift reused rows of the current matrix to the right position.
 22367      BOTTOM_ROW is the last + 1 row in the current matrix reserved for
 22368      text.  */
 22369   bottom_row = MATRIX_BOTTOM_TEXT_ROW (current_matrix, w);
 22370   bottom_vpos = MATRIX_ROW_VPOS (bottom_row, current_matrix);
 22371   if (dvpos < 0)
 22372     {
 22373       rotate_matrix (current_matrix, first_unchanged_at_end_vpos + dvpos,
 22374                      bottom_vpos, dvpos);
 22375       clear_glyph_matrix_rows (current_matrix, bottom_vpos + dvpos,
 22376                                bottom_vpos);
 22377     }
 22378   else if (dvpos > 0)
 22379     {
 22380       rotate_matrix (current_matrix, first_unchanged_at_end_vpos,
 22381                      bottom_vpos, dvpos);
 22382       clear_glyph_matrix_rows (current_matrix, first_unchanged_at_end_vpos,
 22383                                first_unchanged_at_end_vpos + dvpos);
 22384     }
 22385 
 22386   /* For frame-based redisplay, make sure that current frame and window
 22387      matrix are in sync with respect to glyph memory.  */
 22388   if (!FRAME_WINDOW_P (f))
 22389     sync_frame_with_window_matrix_rows (w);
 22390 
 22391   /* Adjust buffer positions in reused rows.  */
 22392   if (delta || delta_bytes)
 22393     increment_matrix_positions (current_matrix,
 22394                                 first_unchanged_at_end_vpos + dvpos,
 22395                                 bottom_vpos, delta, delta_bytes);
 22396 
 22397   /* Adjust Y positions.  */
 22398   if (dy)
 22399     shift_glyph_matrix (w, current_matrix,
 22400                         first_unchanged_at_end_vpos + dvpos,
 22401                         bottom_vpos, dy);
 22402 
 22403   if (first_unchanged_at_end_row)
 22404     {
 22405       first_unchanged_at_end_row += dvpos;
 22406       if (first_unchanged_at_end_row->y >= it.last_visible_y
 22407           || !MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row))
 22408         first_unchanged_at_end_row = NULL;
 22409     }
 22410 
 22411   /* If scrolling up, there may be some lines to display at the end of
 22412      the window.  */
 22413   last_text_row_at_end = NULL;
 22414   if (dy < 0)
 22415     {
 22416       /* Scrolling up can leave for example a partially visible line
 22417          at the end of the window to be redisplayed.  */
 22418       /* Set last_row to the glyph row in the current matrix where the
 22419          window end line is found.  It has been moved up or down in
 22420          the matrix by dvpos.  */
 22421       int last_vpos = w->window_end_vpos + dvpos;
 22422       struct glyph_row *last_row = MATRIX_ROW (current_matrix, last_vpos);
 22423 
 22424       /* If last_row is the window end line, it should display text.  */
 22425       eassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_row));
 22426 
 22427       /* If window end line was partially visible before, begin
 22428          displaying at that line.  Otherwise begin displaying with the
 22429          line following it.  */
 22430       if (MATRIX_ROW_BOTTOM_Y (last_row) - dy >= it.last_visible_y)
 22431         {
 22432           init_to_row_start (&it, w, last_row);
 22433           it.vpos = last_vpos;
 22434           it.current_y = last_row->y;
 22435         }
 22436       else
 22437         {
 22438           init_to_row_end (&it, w, last_row);
 22439           it.vpos = 1 + last_vpos;
 22440           it.current_y = MATRIX_ROW_BOTTOM_Y (last_row);
 22441           ++last_row;
 22442         }
 22443 
 22444       /* We may start in a continuation line.  If so, we have to
 22445          get the right continuation_lines_width and current_x.  */
 22446       it.continuation_lines_width = last_row->continuation_lines_width;
 22447       it.hpos = it.current_x = 0;
 22448 
 22449       /* Display the rest of the lines at the window end.  */
 22450       it.glyph_row = MATRIX_ROW (desired_matrix, it.vpos);
 22451       while (it.current_y < it.last_visible_y && !f->fonts_changed)
 22452         {
 22453           /* Is it always sure that the display agrees with lines in
 22454              the current matrix?  I don't think so, so we mark rows
 22455              displayed invalid in the current matrix by setting their
 22456              enabled_p flag to false.  */
 22457           SET_MATRIX_ROW_ENABLED_P (w->current_matrix, it.vpos, false);
 22458           if (display_line (&it, w->cursor.vpos))
 22459             last_text_row_at_end = it.glyph_row - 1;
 22460         }
 22461     }
 22462 
 22463   /* Update window_end_pos and window_end_vpos.  */
 22464   if (first_unchanged_at_end_row && !last_text_row_at_end)
 22465     {
 22466       /* Window end line if one of the preserved rows from the current
 22467          matrix.  Set row to the last row displaying text in current
 22468          matrix starting at first_unchanged_at_end_row, after
 22469          scrolling.  */
 22470       eassert (MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row));
 22471       row = find_last_row_displaying_text (w->current_matrix, &it,
 22472                                            first_unchanged_at_end_row);
 22473       eassume (row && MATRIX_ROW_DISPLAYS_TEXT_P (row));
 22474       adjust_window_ends (w, row, true);
 22475       eassert (w->window_end_bytepos >= 0);
 22476       IF_DEBUG (debug_method_add (w, "A"));
 22477     }
 22478   else if (last_text_row_at_end)
 22479     {
 22480       adjust_window_ends (w, last_text_row_at_end, false);
 22481       eassert (w->window_end_bytepos >= 0);
 22482       IF_DEBUG (debug_method_add (w, "B"));
 22483     }
 22484   else if (last_text_row)
 22485     {
 22486       /* We have displayed either to the end of the window or at the
 22487          end of the window, i.e. the last row with text is to be found
 22488          in the desired matrix.  */
 22489       adjust_window_ends (w, last_text_row, false);
 22490       eassert (w->window_end_bytepos >= 0);
 22491     }
 22492   else if (first_unchanged_at_end_row == NULL
 22493            && last_text_row == NULL
 22494            && last_text_row_at_end == NULL)
 22495     {
 22496       /* Displayed to end of window, but no line containing text was
 22497          displayed.  Lines were deleted at the end of the window.  */
 22498       int first_vpos = window_wants_tab_line (w) + window_wants_header_line (w);
 22499       int vpos = w->window_end_vpos;
 22500       struct glyph_row *current_row = current_matrix->rows + vpos;
 22501       struct glyph_row *desired_row = desired_matrix->rows + vpos;
 22502 
 22503       for (row = NULL; !row; --vpos, --current_row, --desired_row)
 22504         {
 22505           eassert (first_vpos <= vpos);
 22506           if (desired_row->enabled_p)
 22507             {
 22508               if (MATRIX_ROW_DISPLAYS_TEXT_P (desired_row))
 22509                 row = desired_row;
 22510             }
 22511           else if (MATRIX_ROW_DISPLAYS_TEXT_P (current_row))
 22512             row  = current_row;
 22513         }
 22514 
 22515       w->window_end_vpos = vpos + 1;
 22516       w->window_end_pos = Z - MATRIX_ROW_END_CHARPOS (row);
 22517       w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
 22518       eassert (w->window_end_bytepos >= 0);
 22519       IF_DEBUG (debug_method_add (w, "C"));
 22520     }
 22521   else
 22522     emacs_abort ();
 22523 
 22524   IF_DEBUG ((debug_end_pos = w->window_end_pos,
 22525              debug_end_vpos = w->window_end_vpos));
 22526 
 22527   /* Record that display has not been completed.  */
 22528   w->window_end_valid = false;
 22529   w->desired_matrix->no_scrolling_p = true;
 22530   return 3;
 22531 
 22532 #undef GIVE_UP
 22533 }
 22534 
 22535 
 22536 
 22537 /***********************************************************************
 22538                         More debugging support
 22539  ***********************************************************************/
 22540 
 22541 #ifdef GLYPH_DEBUG
 22542 
 22543 void dump_glyph_row (struct glyph_row *, int, int) EXTERNALLY_VISIBLE;
 22544 void dump_glyph_matrix (struct glyph_matrix *, int) EXTERNALLY_VISIBLE;
 22545 void dump_glyph (struct glyph_row *, struct glyph *, int) EXTERNALLY_VISIBLE;
 22546 
 22547 
 22548 /* Dump the contents of glyph matrix MATRIX on stderr.
 22549 
 22550    GLYPHS 0 means don't show glyph contents.
 22551    GLYPHS 1 means show glyphs in short form
 22552    GLYPHS > 1 means show glyphs in long form.  */
 22553 
 22554 void
 22555 dump_glyph_matrix (struct glyph_matrix *matrix, int glyphs)
 22556 {
 22557   int i;
 22558   for (i = 0; i < matrix->nrows; ++i)
 22559     dump_glyph_row (MATRIX_ROW (matrix, i), i, glyphs);
 22560 }
 22561 
 22562 
 22563 /* Dump contents of glyph GLYPH to stderr.  ROW and AREA are
 22564    the glyph row and area where the glyph comes from.  */
 22565 
 22566 void
 22567 dump_glyph (struct glyph_row *row, struct glyph *glyph, int area)
 22568 {
 22569   if (glyph->type == CHAR_GLYPH
 22570       || glyph->type == GLYPHLESS_GLYPH)
 22571     {
 22572       fprintf (stderr,
 22573                "  %5"pD"d     %c %9"pD"d   %c %3d 0x%06x      %c %4d %1.1d%1.1d\n",
 22574                glyph - row->glyphs[TEXT_AREA],
 22575                (glyph->type == CHAR_GLYPH
 22576                 ? 'C'
 22577                 : 'G'),
 22578                glyph->charpos,
 22579                (BUFFERP (glyph->object)
 22580                 ? 'B'
 22581                 : (STRINGP (glyph->object)
 22582                    ? 'S'
 22583                    : (NILP (glyph->object)
 22584                       ? '0'
 22585                       : '-'))),
 22586                glyph->pixel_width,
 22587                glyph->u.ch,
 22588                (glyph->u.ch < 0x80 && glyph->u.ch >= ' '
 22589                 ? (int) glyph->u.ch
 22590                 : '.'),
 22591                glyph->face_id,
 22592                glyph->left_box_line_p,
 22593                glyph->right_box_line_p);
 22594     }
 22595   else if (glyph->type == STRETCH_GLYPH)
 22596     {
 22597       fprintf (stderr,
 22598                "  %5"pD"d     %c %9"pD"d   %c %3d 0x%06x      %c %4d %1.1d%1.1d\n",
 22599                glyph - row->glyphs[TEXT_AREA],
 22600                'S',
 22601                glyph->charpos,
 22602                (BUFFERP (glyph->object)
 22603                 ? 'B'
 22604                 : (STRINGP (glyph->object)
 22605                    ? 'S'
 22606                    : (NILP (glyph->object)
 22607                       ? '0'
 22608                       : '-'))),
 22609                glyph->pixel_width,
 22610                0u,
 22611                ' ',
 22612                glyph->face_id,
 22613                glyph->left_box_line_p,
 22614                glyph->right_box_line_p);
 22615     }
 22616   else if (glyph->type == IMAGE_GLYPH)
 22617     {
 22618       fprintf (stderr,
 22619                "  %5"pD"d     %c %9"pD"d   %c %3d 0x%06x      %c %4d %1.1d%1.1d\n",
 22620                glyph - row->glyphs[TEXT_AREA],
 22621                'I',
 22622                glyph->charpos,
 22623                (BUFFERP (glyph->object)
 22624                 ? 'B'
 22625                 : (STRINGP (glyph->object)
 22626                    ? 'S'
 22627                    : (NILP (glyph->object)
 22628                       ? '0'
 22629                       : '-'))),
 22630                glyph->pixel_width,
 22631                (unsigned int) glyph->u.img_id,
 22632                '.',
 22633                glyph->face_id,
 22634                glyph->left_box_line_p,
 22635                glyph->right_box_line_p);
 22636     }
 22637   else if (glyph->type == COMPOSITE_GLYPH)
 22638     {
 22639       fprintf (stderr,
 22640                "  %5"pD"d     %c %9"pD"d   %c %3d 0x%06x",
 22641                glyph - row->glyphs[TEXT_AREA],
 22642                '+',
 22643                glyph->charpos,
 22644                (BUFFERP (glyph->object)
 22645                 ? 'B'
 22646                 : (STRINGP (glyph->object)
 22647                    ? 'S'
 22648                    : (NILP (glyph->object)
 22649                       ? '0'
 22650                       : '-'))),
 22651                glyph->pixel_width,
 22652                (unsigned int) glyph->u.cmp.id);
 22653       if (glyph->u.cmp.automatic)
 22654         fprintf (stderr,
 22655                  "[%d-%d]",
 22656                  glyph->slice.cmp.from, glyph->slice.cmp.to);
 22657       fprintf (stderr, " . %4d %1.1d%1.1d\n",
 22658                glyph->face_id,
 22659                glyph->left_box_line_p,
 22660                glyph->right_box_line_p);
 22661     }
 22662   else if (glyph->type == XWIDGET_GLYPH)
 22663     {
 22664 #ifndef HAVE_XWIDGETS
 22665       eassume (false);
 22666 #else
 22667       fprintf (stderr,
 22668                "  %5td %4c %6td %c %3d %7p %c %4d %1.1d%1.1d\n",
 22669                glyph - row->glyphs[TEXT_AREA],
 22670                'X',
 22671                glyph->charpos,
 22672                (BUFFERP (glyph->object)
 22673                 ? 'B'
 22674                 : (STRINGP (glyph->object)
 22675                    ? 'S'
 22676                    : '-')),
 22677                glyph->pixel_width,
 22678                glyph->u.xwidget,
 22679                '.',
 22680                glyph->face_id,
 22681                glyph->left_box_line_p,
 22682                glyph->right_box_line_p);
 22683 #endif
 22684     }
 22685 }
 22686 
 22687 
 22688 /* Dump the contents of glyph row at VPOS in MATRIX to stderr.
 22689    GLYPHS 0 means don't show glyph contents.
 22690    GLYPHS 1 means show glyphs in short form
 22691    GLYPHS > 1 means show glyphs in long form.  */
 22692 
 22693 void
 22694 dump_glyph_row (struct glyph_row *row, int vpos, int glyphs)
 22695 {
 22696   if (glyphs != 1)
 22697     {
 22698       fputs (("Row     Start       End Used oE><\\CTZFesm     X    Y    W    H    V    A    P\n"
 22699               "==============================================================================\n"),
 22700              stderr);
 22701       fprintf (stderr, "%3d %9"pD"d %9"pD"d %4d %1.1d%1.1d%1.1d%1.1d\
 22702 %1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d  %4d %4d %4d %4d %4d %4d %4d\n",
 22703                vpos,
 22704                MATRIX_ROW_START_CHARPOS (row),
 22705                MATRIX_ROW_END_CHARPOS (row),
 22706                row->used[TEXT_AREA],
 22707                row->contains_overlapping_glyphs_p,
 22708                row->enabled_p,
 22709                row->truncated_on_left_p,
 22710                row->truncated_on_right_p,
 22711                row->continued_p,
 22712                MATRIX_ROW_CONTINUATION_LINE_P (row),
 22713                MATRIX_ROW_DISPLAYS_TEXT_P (row),
 22714                row->ends_at_zv_p,
 22715                row->fill_line_p,
 22716                row->ends_in_middle_of_char_p,
 22717                row->starts_in_middle_of_char_p,
 22718                row->mouse_face_p,
 22719                row->x,
 22720                row->y,
 22721                row->pixel_width,
 22722                row->height,
 22723                row->visible_height,
 22724                row->ascent,
 22725                row->phys_ascent);
 22726       /* The next 3 lines should align to "Start" in the header.  */
 22727       fprintf (stderr, "    %9"pD"d %9"pD"d\t%5d\n", row->start.overlay_string_index,
 22728                row->end.overlay_string_index,
 22729                row->continuation_lines_width);
 22730       fprintf (stderr, "    %9"pD"d %9"pD"d\n",
 22731                CHARPOS (row->start.string_pos),
 22732                CHARPOS (row->end.string_pos));
 22733       fprintf (stderr, "    %9d %9d\n", row->start.dpvec_index,
 22734                row->end.dpvec_index);
 22735     }
 22736 
 22737   if (glyphs > 1)
 22738     {
 22739       int area;
 22740 
 22741       for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
 22742         {
 22743           struct glyph *glyph = row->glyphs[area];
 22744           struct glyph *glyph_end = glyph + row->used[area];
 22745 
 22746           /* Glyph for a line end in text.  */
 22747           if (area == TEXT_AREA && glyph == glyph_end && glyph->charpos > 0)
 22748             ++glyph_end;
 22749 
 22750           if (glyph < glyph_end)
 22751             fputs (" Glyph#  Type       Pos   O   W     Code      C Face LR\n",
 22752                    stderr);
 22753 
 22754           for (; glyph < glyph_end; ++glyph)
 22755             dump_glyph (row, glyph, area);
 22756         }
 22757     }
 22758   else if (glyphs == 1)
 22759     {
 22760       int area;
 22761       char s[SHRT_MAX + 4];
 22762 
 22763       for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
 22764         {
 22765           int i;
 22766 
 22767           for (i = 0; i < row->used[area]; ++i)
 22768             {
 22769               struct glyph *glyph = row->glyphs[area] + i;
 22770               if (i == row->used[area] - 1
 22771                   && area == TEXT_AREA
 22772                   && NILP (glyph->object)
 22773                   && glyph->type == CHAR_GLYPH
 22774                   && glyph->u.ch == ' ')
 22775                 {
 22776                   strcpy (&s[i], "[\\n]");
 22777                   i += 4;
 22778                 }
 22779               else if (glyph->type == CHAR_GLYPH
 22780                        && glyph->u.ch < 0x80
 22781                        && glyph->u.ch >= ' ')
 22782                 s[i] = glyph->u.ch;
 22783               else
 22784                 s[i] = '.';
 22785             }
 22786 
 22787           s[i] = '\0';
 22788           fprintf (stderr, "%3d: (%d) '%s'\n", vpos, row->enabled_p, s);
 22789         }
 22790     }
 22791 }
 22792 
 22793 
 22794 DEFUN ("dump-glyph-matrix", Fdump_glyph_matrix,
 22795        Sdump_glyph_matrix, 0, 1, "p",
 22796        doc: /* Dump the current matrix of the selected window to stderr.
 22797 Shows contents of glyph row structures.  With non-nil
 22798 parameter GLYPHS, dump glyphs as well.  If GLYPHS is 1 show
 22799 glyphs in short form, otherwise show glyphs in long form.
 22800 
 22801 Interactively, no argument means show glyphs in short form;
 22802 with numeric argument, its value is passed as the GLYPHS flag.  */)
 22803   (Lisp_Object glyphs)
 22804 {
 22805   struct window *w = XWINDOW (selected_window);
 22806   struct buffer *buffer = XBUFFER (w->contents);
 22807 
 22808   fprintf (stderr, "PT = %"pD"d, BEGV = %"pD"d. ZV = %"pD"d\n",
 22809            BUF_PT (buffer), BUF_BEGV (buffer), BUF_ZV (buffer));
 22810   fprintf (stderr, "Cursor x = %d, y = %d, hpos = %d, vpos = %d\n",
 22811            w->cursor.x, w->cursor.y, w->cursor.hpos, w->cursor.vpos);
 22812   fputs ("=============================================\n", stderr);
 22813   dump_glyph_matrix (w->current_matrix,
 22814                      TYPE_RANGED_FIXNUMP (int, glyphs) ? XFIXNUM (glyphs) : 0);
 22815   return Qnil;
 22816 }
 22817 
 22818 
 22819 DEFUN ("dump-frame-glyph-matrix", Fdump_frame_glyph_matrix,
 22820        Sdump_frame_glyph_matrix, 0, 0, "", doc: /* Dump the current glyph matrix of the selected frame to stderr.
 22821 Only text-mode frames have frame glyph matrices.  */)
 22822   (void)
 22823 {
 22824   struct frame *f = XFRAME (selected_frame);
 22825 
 22826   if (f->current_matrix)
 22827     dump_glyph_matrix (f->current_matrix, 1);
 22828   else
 22829     fputs ("*** This frame doesn't have a frame glyph matrix ***\n", stderr);
 22830   return Qnil;
 22831 }
 22832 
 22833 
 22834 DEFUN ("dump-glyph-row", Fdump_glyph_row, Sdump_glyph_row, 1, 2, "P",
 22835        doc: /* Dump glyph row ROW to stderr.
 22836 Interactively, ROW is the prefix numeric argument and defaults to
 22837 the row which displays point.
 22838 Optional argument GLYPHS 0 means don't dump glyphs.
 22839 GLYPHS 1 means dump glyphs in short form.
 22840 GLYPHS > 1 or omitted means dump glyphs in long form.  */)
 22841   (Lisp_Object row, Lisp_Object glyphs)
 22842 {
 22843   struct glyph_matrix *matrix;
 22844   EMACS_INT vpos;
 22845 
 22846   if (NILP (row))
 22847     {
 22848       int d1, d2, d3, d4, d5, ypos;
 22849       bool visible_p = pos_visible_p (XWINDOW (selected_window), PT,
 22850                                       &d1, &d2, &d3, &d4, &d5, &ypos);
 22851       if (visible_p)
 22852         vpos = ypos;
 22853       else
 22854         vpos = 0;
 22855     }
 22856   else
 22857     {
 22858       CHECK_FIXNUM (row);
 22859       vpos = XFIXNUM (row);
 22860     }
 22861   matrix = XWINDOW (selected_window)->current_matrix;
 22862   if (vpos >= 0 && vpos < matrix->nrows)
 22863     dump_glyph_row (MATRIX_ROW (matrix, vpos),
 22864                     vpos,
 22865                     TYPE_RANGED_FIXNUMP (int, glyphs) ? XFIXNUM (glyphs) : 2);
 22866   return Qnil;
 22867 }
 22868 
 22869 
 22870 DEFUN ("dump-tab-bar-row", Fdump_tab_bar_row, Sdump_tab_bar_row, 1, 2, "P",
 22871        doc: /* Dump glyph row ROW of the tab-bar of the current frame to stderr.
 22872 Interactively, ROW is the prefix numeric argument and defaults to zero.
 22873 GLYPHS 0 means don't dump glyphs.
 22874 GLYPHS 1 means dump glyphs in short form.
 22875 GLYPHS > 1 or omitted means dump glyphs in long form.
 22876 
 22877 If there's no tab-bar, or if the tab-bar is not drawn by Emacs,
 22878 do nothing.  */)
 22879   (Lisp_Object row, Lisp_Object glyphs)
 22880 {
 22881 #if defined (HAVE_WINDOW_SYSTEM)
 22882   struct frame *sf = SELECTED_FRAME ();
 22883   struct glyph_matrix *m = WINDOWP (sf->tab_bar_window)
 22884     ? XWINDOW (sf->tab_bar_window)->current_matrix
 22885     : sf->current_matrix;
 22886   EMACS_INT vpos;
 22887 
 22888   if (NILP (row))
 22889     vpos = WINDOWP (sf->tab_bar_window) ? 0 :
 22890       FRAME_MENU_BAR_LINES (sf) > 0 ? 1 : 0;
 22891   else
 22892     {
 22893       CHECK_FIXNUM (row);
 22894       vpos = XFIXNUM (row);
 22895     }
 22896   if (vpos >= 0 && vpos < m->nrows)
 22897     dump_glyph_row (MATRIX_ROW (m, vpos), vpos,
 22898                     TYPE_RANGED_FIXNUMP (int, glyphs) ? XFIXNUM (glyphs) : 2);
 22899 #endif
 22900   return Qnil;
 22901 }
 22902 
 22903 DEFUN ("dump-tool-bar-row", Fdump_tool_bar_row, Sdump_tool_bar_row, 1, 2, "P",
 22904        doc: /* Dump glyph row ROW of the tool-bar of the current frame to stderr.
 22905 Interactively, ROW is the prefix numeric argument and defaults to zero.
 22906 GLYPHS 0 means don't dump glyphs.
 22907 GLYPHS 1 means dump glyphs in short form.
 22908 GLYPHS > 1 or omitted means dump glyphs in long form.
 22909 
 22910 If there's no tool-bar, or if the tool-bar is not drawn by Emacs,
 22911 do nothing.  */)
 22912   (Lisp_Object row, Lisp_Object glyphs)
 22913 {
 22914 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (HAVE_EXT_TOOL_BAR)
 22915   struct frame *sf = SELECTED_FRAME ();
 22916   struct glyph_matrix *m = XWINDOW (sf->tool_bar_window)->current_matrix;
 22917   EMACS_INT vpos;
 22918 
 22919   if (NILP (row))
 22920     vpos = 0;
 22921   else
 22922     {
 22923       CHECK_FIXNUM (row);
 22924       vpos = XFIXNUM (row);
 22925     }
 22926   if (vpos >= 0 && vpos < m->nrows)
 22927     dump_glyph_row (MATRIX_ROW (m, vpos), vpos,
 22928                     TYPE_RANGED_FIXNUMP (int, glyphs) ? XFIXNUM (glyphs) : 2);
 22929 #endif
 22930   return Qnil;
 22931 }
 22932 
 22933 
 22934 DEFUN ("trace-redisplay", Ftrace_redisplay, Strace_redisplay, 0, 1, "P",
 22935        doc: /* Toggle tracing of redisplay.
 22936 With ARG, turn tracing on if and only if ARG is positive.  */)
 22937   (Lisp_Object arg)
 22938 {
 22939   if (NILP (arg))
 22940     trace_redisplay_p = !trace_redisplay_p;
 22941   else
 22942     {
 22943       arg = Fprefix_numeric_value (arg);
 22944       trace_redisplay_p = XFIXNUM (arg) > 0;
 22945     }
 22946 
 22947   return Qnil;
 22948 }
 22949 
 22950 
 22951 DEFUN ("trace-to-stderr", Ftrace_to_stderr, Strace_to_stderr, 1, MANY, "",
 22952        doc: /* Like `format', but print result to stderr.
 22953 usage: (trace-to-stderr STRING &rest OBJECTS)  */)
 22954   (ptrdiff_t nargs, Lisp_Object *args)
 22955 {
 22956   Lisp_Object s = Fformat (nargs, args);
 22957   fwrite (SDATA (s), 1, SBYTES (s), stderr);
 22958   return Qnil;
 22959 }
 22960 
 22961 #endif /* GLYPH_DEBUG */
 22962 
 22963 
 22964 
 22965 /***********************************************************************
 22966                      Building Desired Matrix Rows
 22967  ***********************************************************************/
 22968 
 22969 /* Return a temporary glyph row holding the glyphs of an overlay arrow.
 22970    Used for non-window-redisplay windows, and for windows without left
 22971    fringe.  */
 22972 
 22973 static struct glyph_row *
 22974 get_overlay_arrow_glyph_row (struct window *w, Lisp_Object overlay_arrow_string)
 22975 {
 22976   struct frame *f = XFRAME (WINDOW_FRAME (w));
 22977   struct buffer *buffer = XBUFFER (w->contents);
 22978   struct buffer *old = current_buffer;
 22979   const unsigned char *arrow_string = SDATA (overlay_arrow_string);
 22980   ptrdiff_t arrow_len = SBYTES (overlay_arrow_string), char_num = 0;
 22981   const unsigned char *arrow_end = arrow_string + arrow_len;
 22982   const unsigned char *p;
 22983   struct it it;
 22984   bool multibyte_p;
 22985   int n_glyphs_before;
 22986 
 22987   set_buffer_temp (buffer);
 22988   init_iterator (&it, w, -1, -1, &scratch_glyph_row, DEFAULT_FACE_ID);
 22989   scratch_glyph_row.reversed_p = false;
 22990   it.glyph_row->used[TEXT_AREA] = 0;
 22991   SET_TEXT_POS (it.position, 0, 0);
 22992 
 22993   multibyte_p = !NILP (BVAR (buffer, enable_multibyte_characters));
 22994   p = arrow_string;
 22995   while (p < arrow_end)
 22996     {
 22997       Lisp_Object face, ilisp;
 22998 
 22999       /* Get the next character.  */
 23000       if (multibyte_p)
 23001         it.c = it.char_to_display = check_char_and_length (p, &it.len);
 23002       else
 23003         {
 23004           it.c = it.char_to_display = *p, it.len = 1;
 23005           if (! ASCII_CHAR_P (it.c))
 23006             it.char_to_display = BYTE8_TO_CHAR (it.c);
 23007         }
 23008       p += it.len;
 23009 
 23010       /* Get its face.  */
 23011       ilisp = make_fixnum (char_num++);
 23012       face = Fget_text_property (ilisp, Qface, overlay_arrow_string);
 23013       it.face_id = compute_char_face (f, it.char_to_display, face);
 23014 
 23015       /* Compute its width, get its glyphs.  */
 23016       n_glyphs_before = it.glyph_row->used[TEXT_AREA];
 23017       SET_TEXT_POS (it.position, -1, -1);
 23018       PRODUCE_GLYPHS (&it);
 23019 
 23020       /* If this character doesn't fit any more in the line, we have
 23021          to remove some glyphs.  */
 23022       if (it.current_x > it.last_visible_x)
 23023         {
 23024           it.glyph_row->used[TEXT_AREA] = n_glyphs_before;
 23025           break;
 23026         }
 23027     }
 23028 
 23029   set_buffer_temp (old);
 23030   return it.glyph_row;
 23031 }
 23032 
 23033 
 23034 /* Insert truncation glyphs at the start of IT->glyph_row.  Which
 23035    glyphs to insert is determined by produce_special_glyphs.  */
 23036 
 23037 static void
 23038 insert_left_trunc_glyphs (struct it *it)
 23039 {
 23040   struct it truncate_it;
 23041   struct glyph *from, *end, *to, *toend;
 23042 
 23043   eassert (!FRAME_WINDOW_P (it->f)
 23044            || (!it->glyph_row->reversed_p
 23045                && WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0)
 23046            || (it->glyph_row->reversed_p
 23047                && WINDOW_RIGHT_FRINGE_WIDTH (it->w) == 0));
 23048 
 23049   /* Get the truncation glyphs.  */
 23050   truncate_it = *it;
 23051   truncate_it.current_x = 0;
 23052   truncate_it.face_id = DEFAULT_FACE_ID;
 23053   truncate_it.glyph_row = &scratch_glyph_row;
 23054   truncate_it.area = TEXT_AREA;
 23055   truncate_it.glyph_row->used[TEXT_AREA] = 0;
 23056   CHARPOS (truncate_it.position) = BYTEPOS (truncate_it.position) = -1;
 23057   truncate_it.object = Qnil;
 23058   produce_special_glyphs (&truncate_it, IT_TRUNCATION);
 23059 
 23060   /* Overwrite glyphs from IT with truncation glyphs.  */
 23061   if (!it->glyph_row->reversed_p)
 23062     {
 23063       short tused = truncate_it.glyph_row->used[TEXT_AREA];
 23064 
 23065       from = truncate_it.glyph_row->glyphs[TEXT_AREA];
 23066       end = from + tused;
 23067       to = it->glyph_row->glyphs[TEXT_AREA];
 23068       toend = to + it->glyph_row->used[TEXT_AREA];
 23069       if (FRAME_WINDOW_P (it->f))
 23070         {
 23071           /* On GUI frames, when variable-size fonts are displayed,
 23072              the truncation glyphs may need more pixels than the row's
 23073              glyphs they overwrite.  We overwrite more glyphs to free
 23074              enough screen real estate, and enlarge the stretch glyph
 23075              on the right (see display_line), if there is one, to
 23076              preserve the screen position of the truncation glyphs on
 23077              the right.  */
 23078           int w = 0;
 23079           struct glyph *g = to;
 23080           short used;
 23081 
 23082           /* The first glyph could be partially visible, in which case
 23083              it->glyph_row->x will be negative.  But we want the left
 23084              truncation glyphs to be aligned at the left margin of the
 23085              window, so we override the x coordinate at which the row
 23086              will begin.  */
 23087           it->glyph_row->x = 0;
 23088           while (g < toend && w < it->truncation_pixel_width)
 23089             {
 23090               w += g->pixel_width;
 23091               ++g;
 23092             }
 23093           if (g - to - tused > 0)
 23094             {
 23095               memmove (to + tused, g, (toend - g) * sizeof(*g));
 23096               it->glyph_row->used[TEXT_AREA] -= g - to - tused;
 23097             }
 23098           used = it->glyph_row->used[TEXT_AREA];
 23099           if (it->glyph_row->truncated_on_right_p
 23100               && WINDOW_RIGHT_FRINGE_WIDTH (it->w) == 0
 23101               && it->glyph_row->glyphs[TEXT_AREA][used - 2].type
 23102               == STRETCH_GLYPH)
 23103             {
 23104               int extra = w - it->truncation_pixel_width;
 23105 
 23106               it->glyph_row->glyphs[TEXT_AREA][used - 2].pixel_width += extra;
 23107             }
 23108         }
 23109 
 23110       while (from < end)
 23111         *to++ = *from++;
 23112 
 23113       /* There may be padding glyphs left over.  Overwrite them too.  */
 23114       if (!FRAME_WINDOW_P (it->f))
 23115         {
 23116           while (to < toend && CHAR_GLYPH_PADDING_P (*to))
 23117             {
 23118               from = truncate_it.glyph_row->glyphs[TEXT_AREA];
 23119               while (from < end)
 23120                 *to++ = *from++;
 23121             }
 23122         }
 23123 
 23124       if (to > toend)
 23125         it->glyph_row->used[TEXT_AREA] = to - it->glyph_row->glyphs[TEXT_AREA];
 23126     }
 23127   else
 23128     {
 23129       short tused = truncate_it.glyph_row->used[TEXT_AREA];
 23130 
 23131       /* In R2L rows, overwrite the last (rightmost) glyphs, and do
 23132          that back to front.  */
 23133       end = truncate_it.glyph_row->glyphs[TEXT_AREA];
 23134       from = end + truncate_it.glyph_row->used[TEXT_AREA] - 1;
 23135       toend = it->glyph_row->glyphs[TEXT_AREA];
 23136       to = toend + it->glyph_row->used[TEXT_AREA] - 1;
 23137       if (FRAME_WINDOW_P (it->f))
 23138         {
 23139           int w = 0;
 23140           struct glyph *g = to;
 23141 
 23142           while (g >= toend && w < it->truncation_pixel_width)
 23143             {
 23144               w += g->pixel_width;
 23145               --g;
 23146             }
 23147           if (to - g - tused > 0)
 23148             to = g + tused;
 23149           if (it->glyph_row->truncated_on_right_p
 23150               && WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0
 23151               && it->glyph_row->glyphs[TEXT_AREA][1].type == STRETCH_GLYPH)
 23152             {
 23153               int extra = w - it->truncation_pixel_width;
 23154 
 23155               it->glyph_row->glyphs[TEXT_AREA][1].pixel_width += extra;
 23156             }
 23157         }
 23158 
 23159       while (from >= end && to >= toend)
 23160         *to-- = *from--;
 23161       if (!FRAME_WINDOW_P (it->f))
 23162         {
 23163           while (to >= toend && CHAR_GLYPH_PADDING_P (*to))
 23164             {
 23165               from =
 23166                 truncate_it.glyph_row->glyphs[TEXT_AREA]
 23167                 + truncate_it.glyph_row->used[TEXT_AREA] - 1;
 23168               while (from >= end && to >= toend)
 23169                 *to-- = *from--;
 23170             }
 23171         }
 23172       if (from >= end)
 23173         {
 23174           /* Need to free some room before prepending additional
 23175              glyphs.  */
 23176           int move_by = from - end + 1;
 23177           struct glyph *g0 = it->glyph_row->glyphs[TEXT_AREA];
 23178           struct glyph *g = g0 + it->glyph_row->used[TEXT_AREA] - 1;
 23179 
 23180           for ( ; g >= g0; g--)
 23181             g[move_by] = *g;
 23182           while (from >= end)
 23183             *to-- = *from--;
 23184           it->glyph_row->used[TEXT_AREA] += move_by;
 23185         }
 23186     }
 23187 }
 23188 
 23189 /* Compute the hash code for ROW.  */
 23190 unsigned
 23191 row_hash (struct glyph_row *row)
 23192 {
 23193   int area, k;
 23194   unsigned hashval = 0;
 23195 
 23196   for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
 23197     for (k = 0; k < row->used[area]; ++k)
 23198       hashval = ((((hashval << 4) + (hashval >> 24)) & 0x0fffffff)
 23199                   + row->glyphs[area][k].u.val
 23200                   + row->glyphs[area][k].face_id
 23201                   + row->glyphs[area][k].padding_p
 23202                   + (row->glyphs[area][k].type << 2));
 23203 
 23204   return hashval;
 23205 }
 23206 
 23207 /* Compute the pixel height and width of IT->glyph_row.
 23208 
 23209    Most of the time, ascent and height of a display line will be equal
 23210    to the max_ascent and max_height values of the display iterator
 23211    structure.  This is not the case if
 23212 
 23213    1. We hit ZV without displaying anything.  In this case, max_ascent
 23214    and max_height will be zero.
 23215 
 23216    2. We have some glyphs that don't contribute to the line height.
 23217    (The glyph row flag contributes_to_line_height_p is for future
 23218    pixmap extensions).
 23219 
 23220    The first case is easily covered by using default values because in
 23221    these cases, the line height does not really matter, except that it
 23222    must not be zero.  */
 23223 
 23224 static void
 23225 compute_line_metrics (struct it *it)
 23226 {
 23227   struct glyph_row *row = it->glyph_row;
 23228 
 23229   if (FRAME_WINDOW_P (it->f))
 23230     {
 23231       int i, min_y, max_y;
 23232 
 23233       /* The line may consist of one space only, that was added to
 23234          place the cursor on it.  If so, the row's height hasn't been
 23235          computed yet.  */
 23236       if (row->height == 0)
 23237         {
 23238           if (it->max_ascent + it->max_descent == 0)
 23239             it->max_descent = it->max_phys_descent = FRAME_LINE_HEIGHT (it->f);
 23240           row->ascent = it->max_ascent;
 23241           row->height = it->max_ascent + it->max_descent;
 23242           row->phys_ascent = it->max_phys_ascent;
 23243           row->phys_height = it->max_phys_ascent + it->max_phys_descent;
 23244           row->extra_line_spacing = it->max_extra_line_spacing;
 23245         }
 23246 
 23247       /* Compute the width of this line.  */
 23248       row->pixel_width = row->x;
 23249       for (i = 0; i < row->used[TEXT_AREA]; ++i)
 23250         row->pixel_width += row->glyphs[TEXT_AREA][i].pixel_width;
 23251 
 23252       eassert (row->pixel_width >= 0);
 23253       eassert (row->ascent >= 0 && row->height > 0);
 23254 
 23255       row->overlapping_p = (MATRIX_ROW_OVERLAPS_SUCC_P (row)
 23256                             || MATRIX_ROW_OVERLAPS_PRED_P (row));
 23257 
 23258       /* If first line's physical ascent is larger than its logical
 23259          ascent, use the physical ascent, and make the row taller.
 23260          This makes accented characters fully visible.  */
 23261       if (row == MATRIX_FIRST_TEXT_ROW (it->w->desired_matrix)
 23262           && row->phys_ascent > row->ascent)
 23263         {
 23264           row->height += row->phys_ascent - row->ascent;
 23265           row->ascent = row->phys_ascent;
 23266         }
 23267 
 23268       /* Compute how much of the line is visible.  */
 23269       row->visible_height = row->height;
 23270 
 23271       min_y = WINDOW_TAB_LINE_HEIGHT (it->w) + WINDOW_HEADER_LINE_HEIGHT (it->w);
 23272       max_y = WINDOW_BOX_HEIGHT_NO_MODE_LINE (it->w);
 23273 
 23274       if (row->y < min_y)
 23275         row->visible_height -= min_y - row->y;
 23276       if (row->y + row->height > max_y)
 23277         row->visible_height -= row->y + row->height - max_y;
 23278     }
 23279   else
 23280     {
 23281       row->pixel_width = row->used[TEXT_AREA];
 23282       if (row->continued_p)
 23283         row->pixel_width -= it->continuation_pixel_width;
 23284       else if (row->truncated_on_right_p)
 23285         row->pixel_width -= it->truncation_pixel_width;
 23286       row->ascent = row->phys_ascent = 0;
 23287       row->height = row->phys_height = row->visible_height = 1;
 23288       row->extra_line_spacing = 0;
 23289     }
 23290 
 23291   /* Compute a hash code for this row.  */
 23292   row->hash = row_hash (row);
 23293 
 23294   it->max_ascent = it->max_descent = 0;
 23295   it->max_phys_ascent = it->max_phys_descent = 0;
 23296 }
 23297 
 23298 
 23299 static void
 23300 clear_position (struct it *it)
 23301 {
 23302   it->position.charpos = 0;
 23303   it->position.bytepos = 0;
 23304 }
 23305 
 23306 /* Append one space to the glyph row of iterator IT if doing a
 23307    window-based redisplay.  The space has the same face as
 23308    IT->face_id.  Value is true if a space was added.
 23309 
 23310    This function is called to make sure that there is always one glyph
 23311    at the end of a glyph row that the cursor can be set on under
 23312    window-systems.  (If there weren't such a glyph we would not know
 23313    how wide and tall a box cursor should be displayed).
 23314 
 23315    At the same time this space let's a nicely handle clearing to the
 23316    end of the line if the row ends in italic text.  */
 23317 
 23318 static bool
 23319 append_space_for_newline (struct it *it, bool default_face_p)
 23320 {
 23321   int n = it->glyph_row->used[TEXT_AREA];
 23322 
 23323   if (it->glyph_row->glyphs[TEXT_AREA] + n
 23324       < it->glyph_row->glyphs[1 + TEXT_AREA])
 23325     {
 23326       /* Save some values that must not be changed.
 23327          Must save IT->c and IT->len because otherwise
 23328          ITERATOR_AT_END_P wouldn't work anymore after
 23329          append_space_for_newline has been called.  */
 23330       enum display_element_type saved_what = it->what;
 23331       int saved_c = it->c, saved_len = it->len;
 23332       int saved_char_to_display = it->char_to_display;
 23333       int saved_x = it->current_x;
 23334       const int saved_face_id = it->face_id;
 23335       bool saved_box_end = it->end_of_box_run_p;
 23336       struct text_pos saved_pos = it->position;
 23337       Lisp_Object saved_object = it->object;
 23338       struct face *face;
 23339 
 23340       it->what = IT_CHARACTER;
 23341       clear_position (it);
 23342       it->object = Qnil;
 23343       it->len = 1;
 23344 
 23345       int char_width = 1;
 23346 
 23347       if (default_face_p
 23348 #ifdef HAVE_WINDOW_SYSTEM
 23349           || FRAME_WINDOW_P (it->f)
 23350 #endif
 23351           )
 23352         {
 23353           const int local_default_face_id =
 23354             lookup_basic_face (it->w, it->f, DEFAULT_FACE_ID);
 23355 
 23356 #ifdef HAVE_WINDOW_SYSTEM
 23357           if (FRAME_WINDOW_P (it->f))
 23358             {
 23359               struct face *default_face
 23360                 = FACE_FROM_ID (it->f, local_default_face_id);
 23361               struct font *font = (default_face->font
 23362                                    ? default_face->font
 23363                                    : FRAME_FONT (it->f));
 23364               char_width = (font->average_width
 23365                             ? font->average_width
 23366                             : font->space_width);
 23367             }
 23368 #endif
 23369           if (default_face_p)
 23370             it->face_id = local_default_face_id;
 23371         }
 23372       /* Corner case for when display-fill-column-indicator-mode
 23373          is active and the extra character should be added in the
 23374          same place than the line.  */
 23375 
 23376       const int indicator_column =
 23377         fill_column_indicator_column (it, char_width);
 23378       int saved_end_of_box_run = it->end_of_box_run_p;
 23379       bool should_keep_end_of_box_run = false;
 23380 
 23381       if (it->current_x == indicator_column)
 23382         {
 23383           it->c = it->char_to_display
 23384             = XFIXNAT (Vdisplay_fill_column_indicator_character);
 23385           it->face_id
 23386             = merge_faces (it->w, Qfill_column_indicator,
 23387                            0, saved_face_id);
 23388           face = FACE_FROM_ID (it->f, it->face_id);
 23389         }
 23390       else
 23391         {
 23392           it->c = it->char_to_display = ' ';
 23393           /* If the default face was remapped, be sure to use the
 23394              remapped face for the appended newline.  */
 23395 
 23396           face = FACE_FROM_ID (it->f, it->face_id);
 23397           it->face_id = FACE_FOR_CHAR (it->f, face, 0, -1, Qnil);
 23398           /* In R2L rows, we will prepend a stretch glyph that will
 23399              have the end_of_box_run_p flag set for it, so there's no
 23400              need for the appended newline glyph to have that flag
 23401              set.  */
 23402           if (!(it->glyph_row->reversed_p
 23403                 /* But if the appended newline glyph goes all the way to
 23404                    the end of the row, there will be no stretch glyph,
 23405                    so leave the box flag set.  */
 23406                 && saved_x + FRAME_COLUMN_WIDTH (it->f) < it->last_visible_x))
 23407             should_keep_end_of_box_run = true;
 23408         }
 23409       PRODUCE_GLYPHS (it);
 23410       /* Restore the end_of_box_run_p flag which was reset by
 23411          PRODUCE_GLYPHS.  */
 23412       if (should_keep_end_of_box_run)
 23413         it->end_of_box_run_p = saved_end_of_box_run;
 23414 #ifdef HAVE_WINDOW_SYSTEM
 23415       if (FRAME_WINDOW_P (it->f))
 23416         {
 23417           /* Make sure this space glyph has the right ascent and
 23418              descent values, or else cursor at end of line will look
 23419              funny, and height of empty lines will be incorrect.  */
 23420           struct glyph *g = it->glyph_row->glyphs[TEXT_AREA] + n;
 23421           struct font *font = face->font ? face->font : FRAME_FONT (it->f);
 23422           if (n == 0)
 23423             {
 23424               Lisp_Object height, total_height;
 23425               int extra_line_spacing = it->extra_line_spacing;
 23426               int boff = font->baseline_offset;
 23427 
 23428               if (font->vertical_centering)
 23429                 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
 23430 
 23431               it->object = saved_object; /* get_it_property needs this */
 23432               normal_char_ascent_descent (font, -1, &it->ascent, &it->descent);
 23433               /* Must do a subset of line height processing from
 23434                  gui_produce_glyph for newline characters.  */
 23435               height = get_it_property (it, Qline_height);
 23436               if (CONSP (height)
 23437                   && CONSP (XCDR (height))
 23438                   && NILP (XCDR (XCDR (height))))
 23439                 {
 23440                   total_height = XCAR (XCDR (height));
 23441                   height = XCAR (height);
 23442                 }
 23443               else
 23444                 total_height = Qnil;
 23445               height = calc_line_height_property (it, height, font, boff, true);
 23446 
 23447               if (it->override_ascent >= 0)
 23448                 {
 23449                   it->ascent = it->override_ascent;
 23450                   it->descent = it->override_descent;
 23451                   boff = it->override_boff;
 23452                 }
 23453               if (EQ (height, Qt))
 23454                 extra_line_spacing = 0;
 23455               else
 23456                 {
 23457                   Lisp_Object spacing;
 23458 
 23459                   it->phys_ascent = it->ascent;
 23460                   it->phys_descent = it->descent;
 23461                   if (!NILP (height)
 23462                       && XFIXNUM (height) > it->ascent + it->descent)
 23463                     it->ascent = XFIXNUM (height) - it->descent;
 23464 
 23465                   if (!NILP (total_height))
 23466                     spacing = calc_line_height_property (it, total_height, font,
 23467                                                          boff, false);
 23468                   else
 23469                     {
 23470                       spacing = get_it_property (it, Qline_spacing);
 23471                       spacing = calc_line_height_property (it, spacing, font,
 23472                                                            boff, false);
 23473                     }
 23474                   if (FIXNUMP (spacing))
 23475                     {
 23476                       extra_line_spacing = XFIXNUM (spacing);
 23477                       if (!NILP (total_height))
 23478                         extra_line_spacing -= (it->phys_ascent + it->phys_descent);
 23479                     }
 23480                 }
 23481               if (extra_line_spacing > 0)
 23482                 {
 23483                   it->descent += extra_line_spacing;
 23484                   if (extra_line_spacing > it->max_extra_line_spacing)
 23485                     it->max_extra_line_spacing = extra_line_spacing;
 23486                 }
 23487               it->max_ascent = it->ascent;
 23488               it->max_descent = it->descent;
 23489               /* Make sure compute_line_metrics recomputes the row height.  */
 23490               it->glyph_row->height = 0;
 23491             }
 23492 
 23493           g->ascent = it->max_ascent;
 23494           g->descent = it->max_descent;
 23495         }
 23496 #endif /* HAVE_WINDOW_SYSTEM  */
 23497       it->override_ascent = -1;
 23498       it->constrain_row_ascent_descent_p = false;
 23499       it->current_x = saved_x;
 23500       it->object = saved_object;
 23501       it->position = saved_pos;
 23502       it->what = saved_what;
 23503       it->face_id = saved_face_id;
 23504       it->len = saved_len;
 23505       it->c = saved_c;
 23506       it->char_to_display = saved_char_to_display;
 23507       it->end_of_box_run_p = saved_box_end;
 23508       return true;
 23509     }
 23510 
 23511   return false;
 23512 }
 23513 
 23514 
 23515 /* Extend the face of the last glyph in the text area of IT->glyph_row
 23516    to the end of the display line.  Called from display_line.  If the
 23517    glyph row is empty, add a space glyph to it so that we know the
 23518    face to draw.  Set the glyph row flag fill_line_p.  If the glyph
 23519    row is R2L, prepend a stretch glyph to cover the empty space to the
 23520    left of the leftmost glyph.  */
 23521 
 23522 static void
 23523 extend_face_to_end_of_line (struct it *it)
 23524 {
 23525   struct frame *f = it->f;
 23526 
 23527   /* If line is already filled, do nothing.  Non window-system frames
 23528      get a grace of one more ``pixel'' because their characters are
 23529      1-``pixel'' wide, so they hit the equality too early.  This grace
 23530      is needed only for R2L rows that are not continued, to produce
 23531      one extra blank where we could display the cursor.  */
 23532   if ((it->current_x >= it->last_visible_x
 23533        + (!FRAME_WINDOW_P (f)
 23534           && it->glyph_row->reversed_p
 23535           && !it->glyph_row->continued_p))
 23536       /* If the window has display margins, we will need to extend
 23537          their face even if the text area is filled.  */
 23538       && !(WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 23539            || WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0))
 23540     return;
 23541 
 23542   specpdl_ref count = SPECPDL_INDEX ();
 23543 
 23544   /* Don't allow the user to quit out of face-merging code, in case
 23545      this is called when redisplaying a non-selected window, with
 23546      point temporarily moved to window-point.  */
 23547   specbind (Qinhibit_quit, Qt);
 23548   /* The default face, possibly remapped. */
 23549   struct face *default_face =
 23550     FACE_FROM_ID_OR_NULL (f, lookup_basic_face (it->w, f, DEFAULT_FACE_ID));
 23551   if (!default_face)
 23552     return;
 23553 
 23554   const int extend_face_id =
 23555     (it->face_id == default_face->id || it->s != NULL)
 23556     ? it->face_id
 23557     : (it->glyph_row->ends_at_zv_p
 23558        ? default_face->id
 23559        : face_at_pos (it, LFACE_EXTEND_INDEX));
 23560   unbind_to (count, Qnil);
 23561 
 23562   /* Face extension extends the background and box of IT->extend_face_id
 23563      to the end of the line.  If the background equals the background
 23564      of the frame, we don't have to do anything.  */
 23565   struct face *face = FACE_FROM_ID (f, (it->face_before_selective_p
 23566                                         ? it->saved_face_id
 23567                                         : extend_face_id));
 23568 
 23569   if (FRAME_WINDOW_P (f)
 23570       && MATRIX_ROW_DISPLAYS_TEXT_P (it->glyph_row)
 23571       && face->box == FACE_NO_BOX
 23572       && face->underline == FACE_NO_UNDERLINE
 23573       && !face->overline_p
 23574       && !face->strike_through_p
 23575       && face->background == FRAME_BACKGROUND_PIXEL (f)
 23576 #ifdef HAVE_WINDOW_SYSTEM
 23577       && !face->stipple
 23578 #endif
 23579       && !it->glyph_row->reversed_p
 23580       && !display_fill_column_indicator)
 23581     return;
 23582 
 23583   /* Set the glyph row flag indicating that the face of the last glyph
 23584      in the text area has to be drawn to the end of the text area.  */
 23585   it->glyph_row->fill_line_p = true;
 23586 
 23587   const int orig_face_id = it->face_id;
 23588   /* If current character of IT is not ASCII, make sure we have the
 23589      ASCII face.  This will be automatically undone the next time
 23590      get_next_display_element returns a multibyte character.  Note
 23591      that the character will always be single byte in unibyte
 23592      text.  */
 23593   if (!ASCII_CHAR_P (it->c))
 23594     it->face_id = FACE_FOR_CHAR (f, face, 0, -1, Qnil);
 23595 
 23596 
 23597 #ifdef HAVE_WINDOW_SYSTEM
 23598   if (FRAME_WINDOW_P (f))
 23599     {
 23600       /* If the row is empty, add a space with the current face of IT,
 23601          so that we know which face to draw.  */
 23602       if (it->glyph_row->used[TEXT_AREA] == 0)
 23603         {
 23604           it->glyph_row->glyphs[TEXT_AREA][0] = space_glyph;
 23605           it->glyph_row->glyphs[TEXT_AREA][0].face_id = face->id;
 23606           it->glyph_row->used[TEXT_AREA] = 1;
 23607         }
 23608       /* Mode line and the header line don't have margins, and
 23609          likewise the frame's tool-bar window, if there is any.  */
 23610       if (!(it->glyph_row->mode_line_p
 23611             || (WINDOWP (f->tab_bar_window)
 23612                 && it->w == XWINDOW (f->tab_bar_window))
 23613 #ifndef HAVE_EXT_TOOL_BAR
 23614             || (WINDOWP (f->tool_bar_window)
 23615                 && it->w == XWINDOW (f->tool_bar_window))
 23616 #endif
 23617             ))
 23618         {
 23619           if (WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 23620               && it->glyph_row->used[LEFT_MARGIN_AREA] == 0)
 23621             {
 23622               it->glyph_row->glyphs[LEFT_MARGIN_AREA][0] = space_glyph;
 23623               it->glyph_row->glyphs[LEFT_MARGIN_AREA][0].face_id =
 23624                 default_face->id;
 23625               it->glyph_row->used[LEFT_MARGIN_AREA] = 1;
 23626             }
 23627           if (WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0
 23628               && it->glyph_row->used[RIGHT_MARGIN_AREA] == 0)
 23629             {
 23630               it->glyph_row->glyphs[RIGHT_MARGIN_AREA][0] = space_glyph;
 23631               it->glyph_row->glyphs[RIGHT_MARGIN_AREA][0].face_id =
 23632                 default_face->id;
 23633               it->glyph_row->used[RIGHT_MARGIN_AREA] = 1;
 23634             }
 23635 
 23636           struct font *font = (default_face->font
 23637                                ? default_face->font
 23638                                : FRAME_FONT (f));
 23639 
 23640           const int char_width = (font->average_width
 23641                                   ? font->average_width
 23642                                   : font->space_width);
 23643 
 23644           const int indicator_column =
 23645             fill_column_indicator_column (it, char_width);
 23646 
 23647           const char saved_char = it->char_to_display;
 23648           const struct text_pos saved_pos = it->position;
 23649           const bool saved_avoid_cursor = it->avoid_cursor_p;
 23650           const bool saved_box_start = it->start_of_box_run_p;
 23651           Lisp_Object save_object = it->object;
 23652           const int saved_face_id = it->face_id;
 23653 
 23654           it->face_id = extend_face_id;
 23655           it->avoid_cursor_p = true;
 23656           it->object = Qnil;
 23657 
 23658           const int stretch_height = it->ascent + it->descent;
 23659           const int stretch_ascent =
 23660             (stretch_height * FONT_BASE (font)) / FONT_HEIGHT (font);
 23661 
 23662           if (indicator_column >= 0
 23663               && indicator_column > it->current_x
 23664               && indicator_column < it->last_visible_x)
 23665             {
 23666 
 23667               /* Here we subtract char_width because we want the
 23668                  column indicator in the column INDICATOR_COLUMN,
 23669                  not after it.  */
 23670               const int stretch_width =
 23671                 indicator_column - it->current_x - char_width;
 23672 
 23673               clear_position (it);
 23674 
 23675               /* Only generate a stretch glyph if there is distance
 23676                  between current_x and the indicator position.  */
 23677               if (stretch_width > 0)
 23678                 {
 23679                   append_stretch_glyph (it, Qnil, stretch_width,
 23680                                         stretch_height, stretch_ascent);
 23681                 }
 23682 
 23683               /* Generate the glyph indicator only if
 23684                  append_space_for_newline didn't already.  */
 23685               if (it->current_x < indicator_column)
 23686                 {
 23687                   const int save_face_id = it->face_id;
 23688                   const int save_ascent = it->ascent;
 23689                   const int save_descent = it->descent;
 23690                   it->char_to_display
 23691                     = XFIXNAT (Vdisplay_fill_column_indicator_character);
 23692                   it->face_id
 23693                     = merge_faces (it->w, Qfill_column_indicator,
 23694                                    0, extend_face_id);
 23695                   PRODUCE_GLYPHS (it);
 23696                   it->face_id = save_face_id;
 23697                   it->ascent = save_ascent;
 23698                   it->descent = save_descent;
 23699                 }
 23700             }
 23701 
 23702           /* Fill space until window edge with the merged face.  Do that
 23703              only for L2R rows, as R2L rows are handled specially below.  */
 23704           if (!it->glyph_row->reversed_p)
 23705             {
 23706               const int stretch_width = it->last_visible_x - it->current_x;
 23707 
 23708               if (stretch_width > 0)
 23709                 {
 23710                   clear_position (it);
 23711                   append_stretch_glyph (it, Qnil, stretch_width,
 23712                                         stretch_height, stretch_ascent);
 23713                 }
 23714             }
 23715 
 23716           it->char_to_display = saved_char;
 23717           it->position = saved_pos;
 23718           it->avoid_cursor_p = saved_avoid_cursor;
 23719           it->start_of_box_run_p = saved_box_start;
 23720           it->object = save_object;
 23721           it->face_id = saved_face_id;
 23722         }
 23723       if (it->glyph_row->reversed_p)
 23724         {
 23725           /* Prepend a stretch glyph to the row, such that the
 23726              rightmost glyph will be drawn flushed all the way to the
 23727              right margin of the window.  The stretch glyph that will
 23728              occupy the empty space, if any, to the left of the
 23729              glyph.  */
 23730           struct font *font = face->font ? face->font : FRAME_FONT (f);
 23731           struct glyph *row_start = it->glyph_row->glyphs[TEXT_AREA];
 23732           struct glyph *row_end = row_start + it->glyph_row->used[TEXT_AREA];
 23733           struct glyph *g;
 23734           int row_width, stretch_ascent, stretch_width;
 23735           struct text_pos saved_pos;
 23736           int saved_face_id;
 23737           bool saved_avoid_cursor, saved_box_start;
 23738 
 23739           for (row_width = 0, g = row_start; g < row_end; g++)
 23740             row_width += g->pixel_width;
 23741 
 23742           /* FIXME: There are various minor display glitches in R2L
 23743              rows when only one of the fringes is missing.  The
 23744              strange condition below produces the least bad effect.  */
 23745           if ((WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0)
 23746               == (WINDOW_RIGHT_FRINGE_WIDTH (it->w) == 0)
 23747               || WINDOW_RIGHT_FRINGE_WIDTH (it->w) != 0)
 23748             stretch_width = window_box_width (it->w, TEXT_AREA);
 23749           else
 23750             stretch_width = it->last_visible_x - it->first_visible_x;
 23751           stretch_width -= row_width;
 23752 
 23753           if (stretch_width > 0)
 23754             {
 23755               stretch_ascent =
 23756                 (((it->ascent + it->descent)
 23757                   * FONT_BASE (font)) / FONT_HEIGHT (font));
 23758               saved_pos = it->position;
 23759               clear_position (it);
 23760               saved_avoid_cursor = it->avoid_cursor_p;
 23761               it->avoid_cursor_p = true;
 23762               saved_face_id = it->face_id;
 23763               saved_box_start = it->start_of_box_run_p;
 23764               /* The last row's stretch glyph should get the default
 23765                  face, to avoid painting the rest of the window with
 23766                  the region face, if the region ends at ZV.  */
 23767               it->face_id = (it->glyph_row->ends_at_zv_p ?
 23768                              default_face->id : face->id);
 23769 
 23770               it->start_of_box_run_p = false;
 23771               append_stretch_glyph (it, Qnil, stretch_width,
 23772                                     it->ascent + it->descent, stretch_ascent);
 23773               it->position = saved_pos;
 23774               it->avoid_cursor_p = saved_avoid_cursor;
 23775               it->face_id = saved_face_id;
 23776               it->start_of_box_run_p = saved_box_start;
 23777             }
 23778           /* If stretch_width comes out negative, it means that the
 23779              last glyph is only partially visible.  In R2L rows, we
 23780              want the leftmost glyph to be partially visible, so we
 23781              need to give the row the corresponding left offset.  */
 23782           if (stretch_width < 0)
 23783             it->glyph_row->x = stretch_width;
 23784         }
 23785       it->face_id = orig_face_id;
 23786     }
 23787   else
 23788 #endif  /* HAVE_WINDOW_SYSTEM */
 23789     {
 23790       /* Save some values that must not be changed.  */
 23791       int saved_x = it->current_x;
 23792       struct text_pos saved_pos = it->position;
 23793       Lisp_Object saved_object = it->object;;
 23794       enum display_element_type saved_what = it->what;
 23795 
 23796       it->what = IT_CHARACTER;
 23797       clear_position (it);
 23798       it->object = Qnil;
 23799       it->c = it->char_to_display = ' ';
 23800       it->len = 1;
 23801 
 23802       if (WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 23803           && (it->glyph_row->used[LEFT_MARGIN_AREA]
 23804               < WINDOW_LEFT_MARGIN_WIDTH (it->w))
 23805           && !it->glyph_row->mode_line_p
 23806           && face->background != FRAME_BACKGROUND_PIXEL (f))
 23807         {
 23808           struct glyph *g = it->glyph_row->glyphs[LEFT_MARGIN_AREA];
 23809           struct glyph *e = g + it->glyph_row->used[LEFT_MARGIN_AREA];
 23810 
 23811           for (it->current_x = 0; g < e; g++)
 23812             it->current_x += g->pixel_width;
 23813 
 23814           it->area = LEFT_MARGIN_AREA;
 23815           it->face_id = default_face->id;
 23816           while (it->glyph_row->used[LEFT_MARGIN_AREA]
 23817                  < WINDOW_LEFT_MARGIN_WIDTH (it->w)
 23818                  && g < it->glyph_row->glyphs[TEXT_AREA])
 23819             {
 23820               PRODUCE_GLYPHS (it);
 23821               /* term.c:produce_glyphs advances it->current_x only for
 23822                  TEXT_AREA.  */
 23823               it->current_x += it->pixel_width;
 23824               g++;
 23825             }
 23826 
 23827           it->current_x = saved_x;
 23828           it->area = TEXT_AREA;
 23829         }
 23830 
 23831       /* The last row's blank glyphs should get the default face, to
 23832          avoid painting the rest of the window with the region face,
 23833          if the region ends at ZV.  */
 23834       it->face_id = (it->glyph_row->ends_at_zv_p ?
 23835                      default_face->id : face->id);
 23836 
 23837       /* Make sure our idea of current_x is in sync with the glyphs
 23838          actually in the glyph row.  They might differ because
 23839          append_space_for_newline can insert one glyph without
 23840          updating current_x.  */
 23841       it->current_x = it->glyph_row->used[TEXT_AREA];
 23842 
 23843       /* The above assignment causes the code below to use a
 23844          non-standard semantics of it->current_x: it is measured
 23845          relative to the beginning of the text-area, thus disregarding
 23846          the window's hscroll.  That is why we need to correct the
 23847          indicator column for the hscroll, otherwise the indicator
 23848          will not move together with the text as result of horizontal
 23849          scrolling.  */
 23850       const int indicator_column =
 23851         fill_column_indicator_column (it, 1) - it->first_visible_x;
 23852 
 23853       /* Display fill-column indicator if needed.  */
 23854       while (it->current_x <= it->last_visible_x)
 23855         {
 23856           if (it->current_x != indicator_column)
 23857             PRODUCE_GLYPHS (it);
 23858           else
 23859             {
 23860               int saved_face_id = it->face_id;
 23861               it->face_id
 23862                 = merge_faces (it->w, Qfill_column_indicator, 0, extend_face_id);
 23863               it->c = it->char_to_display
 23864                 = XFIXNAT (Vdisplay_fill_column_indicator_character);
 23865 
 23866               PRODUCE_GLYPHS (it);
 23867 
 23868               it->face_id = saved_face_id;
 23869               it->c = it->char_to_display = ' ';
 23870             }
 23871         }
 23872 
 23873       if (WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0
 23874           && (it->glyph_row->used[RIGHT_MARGIN_AREA]
 23875               < WINDOW_RIGHT_MARGIN_WIDTH (it->w))
 23876           && !it->glyph_row->mode_line_p
 23877           && face->background != FRAME_BACKGROUND_PIXEL (f))
 23878         {
 23879           struct glyph *g = it->glyph_row->glyphs[RIGHT_MARGIN_AREA];
 23880           struct glyph *e = g + it->glyph_row->used[RIGHT_MARGIN_AREA];
 23881 
 23882           for ( ; g < e; g++)
 23883             it->current_x += g->pixel_width;
 23884 
 23885           it->area = RIGHT_MARGIN_AREA;
 23886           it->face_id = default_face->id;
 23887           while (it->glyph_row->used[RIGHT_MARGIN_AREA]
 23888                  < WINDOW_RIGHT_MARGIN_WIDTH (it->w)
 23889                  && g < it->glyph_row->glyphs[LAST_AREA])
 23890             {
 23891               PRODUCE_GLYPHS (it);
 23892               it->current_x += it->pixel_width;
 23893               g++;
 23894             }
 23895 
 23896           it->area = TEXT_AREA;
 23897         }
 23898 
 23899       /* Don't count these blanks really.  It would let us insert a left
 23900          truncation glyph below and make us set the cursor on them, maybe.  */
 23901       it->current_x = saved_x;
 23902       it->object = saved_object;
 23903       it->position = saved_pos;
 23904       it->what = saved_what;
 23905       it->face_id = orig_face_id;
 23906     }
 23907 }
 23908 
 23909 
 23910 /* Value is true if text starting at CHARPOS in current_buffer is
 23911    trailing whitespace.  */
 23912 
 23913 static bool
 23914 trailing_whitespace_p (ptrdiff_t charpos)
 23915 {
 23916   ptrdiff_t bytepos = CHAR_TO_BYTE (charpos);
 23917   int c = 0;
 23918 
 23919   while (bytepos < ZV_BYTE
 23920          && (c = FETCH_BYTE (bytepos),
 23921              c == ' ' || c == '\t'))
 23922     ++bytepos;
 23923 
 23924   if (bytepos >= ZV_BYTE || c == '\n' || c == '\r')
 23925     {
 23926       if (bytepos != PT_BYTE)
 23927         return true;
 23928     }
 23929   return false;
 23930 }
 23931 
 23932 
 23933 /* Highlight trailing whitespace, if any, in row at IT.  */
 23934 
 23935 static void
 23936 highlight_trailing_whitespace (struct it *it)
 23937 {
 23938   struct glyph_row *row = it->glyph_row;
 23939   int used = row->used[TEXT_AREA];
 23940 
 23941   if (used)
 23942     {
 23943       struct glyph *start = row->glyphs[TEXT_AREA];
 23944       struct glyph *glyph = start + used - 1;
 23945 
 23946       if (row->reversed_p)
 23947         {
 23948           /* Right-to-left rows need to be processed in the opposite
 23949              direction, so swap the edge pointers. */
 23950           glyph = start;
 23951           start = row->glyphs[TEXT_AREA] + used - 1;
 23952         }
 23953 
 23954       /* Skip over glyphs inserted to display the cursor at the
 23955          end of a line, for extending the face of the last glyph
 23956          to the end of the line on terminals, and for truncation
 23957          and continuation glyphs.  */
 23958       if (!row->reversed_p)
 23959         {
 23960           while (glyph >= start
 23961                  && (glyph->type == CHAR_GLYPH
 23962                      || glyph->type == STRETCH_GLYPH)
 23963                  && NILP (glyph->object))
 23964             --glyph;
 23965         }
 23966       else
 23967         {
 23968           while (glyph <= start
 23969                  && (glyph->type == CHAR_GLYPH || glyph->type == STRETCH_GLYPH)
 23970                  && NILP (glyph->object))
 23971             ++glyph;
 23972         }
 23973 
 23974       /* If last glyph is a space or stretch, and it's trailing
 23975          whitespace, set the face of all trailing whitespace glyphs in
 23976          IT->glyph_row to `trailing-whitespace'.  */
 23977       if ((row->reversed_p ? glyph <= start : glyph >= start)
 23978           && BUFFERP (glyph->object)
 23979           && (glyph->type == STRETCH_GLYPH
 23980               || (glyph->type == CHAR_GLYPH
 23981                   && glyph->u.ch == ' '))
 23982           && trailing_whitespace_p (glyph->charpos))
 23983         {
 23984           int face_id = lookup_named_face (it->w, it->f, Qtrailing_whitespace, false);
 23985           if (face_id < 0)
 23986             return;
 23987 
 23988           if (!row->reversed_p)
 23989             {
 23990               while (glyph >= start
 23991                      && BUFFERP (glyph->object)
 23992                      && (glyph->type == STRETCH_GLYPH
 23993                          || (glyph->type == CHAR_GLYPH
 23994                              && glyph->u.ch == ' ')))
 23995                 (glyph--)->face_id = face_id;
 23996             }
 23997           else
 23998             {
 23999               while (glyph <= start
 24000                      && BUFFERP (glyph->object)
 24001                      && (glyph->type == STRETCH_GLYPH
 24002                          || (glyph->type == CHAR_GLYPH
 24003                              && glyph->u.ch == ' ')))
 24004                 (glyph++)->face_id = face_id;
 24005             }
 24006         }
 24007     }
 24008 }
 24009 
 24010 
 24011 /* Value is true if glyph row ROW should be
 24012    considered to hold the buffer position CHARPOS.  */
 24013 
 24014 static bool
 24015 row_for_charpos_p (struct glyph_row *row, ptrdiff_t charpos)
 24016 {
 24017   bool result = true;
 24018 
 24019   if (charpos == CHARPOS (row->end.pos)
 24020       || charpos == MATRIX_ROW_END_CHARPOS (row))
 24021     {
 24022       /* Suppose the row ends on a string.
 24023          Unless the row is continued, that means it ends on a newline
 24024          in the string.  If it's anything other than a display string
 24025          (e.g., a before-string from an overlay), we don't want the
 24026          cursor there.  (This heuristic seems to give the optimal
 24027          behavior for the various types of multi-line strings.)
 24028          One exception: if the string has `cursor' property on one of
 24029          its characters, we _do_ want the cursor there.  */
 24030       if (CHARPOS (row->end.string_pos) >= 0)
 24031         {
 24032           if (row->continued_p)
 24033             result = true;
 24034           else
 24035             {
 24036               /* Check for `display' property.  */
 24037               struct glyph *beg = row->glyphs[TEXT_AREA];
 24038               struct glyph *end = beg + row->used[TEXT_AREA] - 1;
 24039               struct glyph *glyph;
 24040 
 24041               result = false;
 24042               for (glyph = end; glyph >= beg; --glyph)
 24043                 if (STRINGP (glyph->object))
 24044                   {
 24045                     Lisp_Object prop
 24046                       = Fget_char_property (make_fixnum (charpos),
 24047                                             Qdisplay, Qnil);
 24048                     result =
 24049                       (!NILP (prop)
 24050                        && display_prop_string_p (prop, glyph->object));
 24051                     /* If there's a `cursor' property on one of the
 24052                        string's characters, this row is a cursor row,
 24053                        even though this is not a display string.  */
 24054                     if (!result)
 24055                       {
 24056                         Lisp_Object s = glyph->object;
 24057 
 24058                         for ( ; glyph >= beg && EQ (glyph->object, s); --glyph)
 24059                           {
 24060                             ptrdiff_t gpos = glyph->charpos;
 24061 
 24062                             if (!NILP (Fget_char_property (make_fixnum (gpos),
 24063                                                            Qcursor, s)))
 24064                               {
 24065                                 result = true;
 24066                                 break;
 24067                               }
 24068                           }
 24069                       }
 24070                     break;
 24071                   }
 24072             }
 24073         }
 24074       else if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))
 24075         {
 24076           /* If the row ends in middle of a real character,
 24077              and the line is continued, we want the cursor here.
 24078              That's because CHARPOS (ROW->end.pos) would equal
 24079              PT if PT is before the character.  */
 24080           if (!row->ends_in_ellipsis_p)
 24081             result = row->continued_p;
 24082           else
 24083           /* If the row ends in an ellipsis, then
 24084              CHARPOS (ROW->end.pos) will equal point after the
 24085              invisible text.  We want that position to be displayed
 24086              after the ellipsis.  */
 24087             result = false;
 24088         }
 24089       /* If the row ends at ZV, display the cursor at the end of that
 24090          row instead of at the start of the row below.  */
 24091       else
 24092         result = row->ends_at_zv_p;
 24093     }
 24094 
 24095   return result;
 24096 }
 24097 
 24098 /* Value is true if glyph row ROW should be
 24099    used to hold the cursor.  */
 24100 
 24101 static bool
 24102 cursor_row_p (struct glyph_row *row)
 24103 {
 24104   return row_for_charpos_p (row, PT);
 24105 }
 24106 
 24107 
 24108 
 24109 /* Push the property PROP so that it will be rendered at the current
 24110    position in IT.  Return true if PROP was successfully pushed, false
 24111    otherwise.  Called from handle_line_prefix to handle the
 24112    `line-prefix' and `wrap-prefix' properties.  */
 24113 
 24114 static bool
 24115 push_prefix_prop (struct it *it, Lisp_Object prop)
 24116 {
 24117   struct text_pos pos =
 24118     STRINGP (it->string) ? it->current.string_pos : it->current.pos;
 24119 
 24120   eassert (it->method == GET_FROM_BUFFER
 24121            || it->method == GET_FROM_DISPLAY_VECTOR
 24122            || it->method == GET_FROM_STRING
 24123            || it->method == GET_FROM_IMAGE);
 24124 
 24125   /* We need to save the current buffer/string position, so it will be
 24126      restored by pop_it, because iterate_out_of_display_property
 24127      depends on that being set correctly, but some situations leave
 24128      it->position not yet set when this function is called.  */
 24129   push_it (it, &pos);
 24130 
 24131   if (STRINGP (prop))
 24132     {
 24133       if (SCHARS (prop) == 0)
 24134         {
 24135           pop_it (it);
 24136           return false;
 24137         }
 24138 
 24139       it->string = prop;
 24140       it->string_from_prefix_prop_p = true;
 24141       it->multibyte_p = STRING_MULTIBYTE (it->string);
 24142       it->current.overlay_string_index = -1;
 24143       IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
 24144       it->end_charpos = it->string_nchars = SCHARS (it->string);
 24145       it->method = GET_FROM_STRING;
 24146       it->stop_charpos = 0;
 24147       it->prev_stop = 0;
 24148       it->base_level_stop = 0;
 24149       it->cmp_it.id = -1;
 24150 
 24151       /* Force paragraph direction to be that of the parent
 24152          buffer/string.  */
 24153       if (it->bidi_p && it->bidi_it.paragraph_dir == R2L)
 24154         it->paragraph_embedding = it->bidi_it.paragraph_dir;
 24155       else
 24156         it->paragraph_embedding = L2R;
 24157 
 24158       /* Set up the bidi iterator for this display string.  */
 24159       if (it->bidi_p)
 24160         {
 24161           it->bidi_it.string.lstring = it->string;
 24162           it->bidi_it.string.s = NULL;
 24163           it->bidi_it.string.schars = it->end_charpos;
 24164           it->bidi_it.string.bufpos = IT_CHARPOS (*it);
 24165           it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
 24166           it->bidi_it.string.unibyte = !it->multibyte_p;
 24167           it->bidi_it.w = it->w;
 24168           bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
 24169         }
 24170     }
 24171   else if (CONSP (prop) && EQ (XCAR (prop), Qspace))
 24172     {
 24173       it->method = GET_FROM_STRETCH;
 24174       it->object = prop;
 24175     }
 24176 #ifdef HAVE_WINDOW_SYSTEM
 24177   else if (IMAGEP (prop))
 24178     {
 24179       it->what = IT_IMAGE;
 24180       it->image_id = lookup_image (it->f, prop, it->face_id);
 24181       it->method = GET_FROM_IMAGE;
 24182     }
 24183 #endif /* HAVE_WINDOW_SYSTEM */
 24184   else
 24185     {
 24186       pop_it (it);              /* bogus display property, give up */
 24187       return false;
 24188     }
 24189 
 24190   return true;
 24191 }
 24192 
 24193 /* Return the character-property PROP at the current position in IT.  */
 24194 
 24195 static Lisp_Object
 24196 get_it_property (struct it *it, Lisp_Object prop)
 24197 {
 24198   Lisp_Object position, object = it->object;
 24199 
 24200   if (STRINGP (object))
 24201     position = make_fixnum (IT_STRING_CHARPOS (*it));
 24202   else if (BUFFERP (object))
 24203     {
 24204       position = make_fixnum (IT_CHARPOS (*it));
 24205       object = it->window;
 24206     }
 24207   else
 24208     return Qnil;
 24209 
 24210   return Fget_char_property (position, prop, object);
 24211 }
 24212 
 24213 /* Return the line-prefix/wrap-prefix property, checking both the
 24214    current IT->OBJECT and the underlying buffer text.  */
 24215 
 24216 static Lisp_Object
 24217 get_line_prefix_it_property (struct it *it, Lisp_Object prop)
 24218 {
 24219   Lisp_Object prefix = get_it_property (it, prop);
 24220 
 24221   /* If we are looking at a display or overlay string, check also the
 24222      underlying buffer text.  */
 24223   if (NILP (prefix) && it->sp > 0 && STRINGP (it->object))
 24224     return Fget_char_property (make_fixnum (IT_CHARPOS (*it)), prop,
 24225                                it->w->contents);
 24226   return prefix;
 24227 }
 24228 
 24229 /* See if there's a line- or wrap-prefix, and if so, push it on IT.  */
 24230 
 24231 static void
 24232 handle_line_prefix (struct it *it)
 24233 {
 24234   Lisp_Object prefix;
 24235 
 24236   if (it->continuation_lines_width > 0)
 24237     {
 24238       prefix = get_line_prefix_it_property (it, Qwrap_prefix);
 24239       if (NILP (prefix))
 24240         prefix = Vwrap_prefix;
 24241     }
 24242   else
 24243     {
 24244       prefix = get_line_prefix_it_property (it, Qline_prefix);
 24245       if (NILP (prefix))
 24246         prefix = Vline_prefix;
 24247     }
 24248   if (! NILP (prefix) && push_prefix_prop (it, prefix))
 24249     {
 24250       /* If the prefix is wider than the window, and we try to wrap
 24251          it, it would acquire its own wrap prefix, and so on till the
 24252          iterator stack overflows.  So, don't wrap the prefix.  */
 24253       it->line_wrap = TRUNCATE;
 24254       it->avoid_cursor_p = true;
 24255     }
 24256 }
 24257 
 24258 
 24259 
 24260 /* Remove N glyphs at the start of a reversed IT->glyph_row.  Called
 24261    only for R2L lines from display_line and display_string, when they
 24262    decide that too many glyphs were produced by PRODUCE_GLYPHS, and
 24263    the line/string needs to be continued on the next glyph row.  */
 24264 static void
 24265 unproduce_glyphs (struct it *it, int n)
 24266 {
 24267   struct glyph *glyph, *end;
 24268 
 24269   eassert (it->glyph_row);
 24270   eassert (it->glyph_row->reversed_p);
 24271   eassert (it->area == TEXT_AREA);
 24272   eassert (n <= it->glyph_row->used[TEXT_AREA]);
 24273 
 24274   if (n > it->glyph_row->used[TEXT_AREA])
 24275     n = it->glyph_row->used[TEXT_AREA];
 24276   glyph = it->glyph_row->glyphs[TEXT_AREA] + n;
 24277   end = it->glyph_row->glyphs[TEXT_AREA] + it->glyph_row->used[TEXT_AREA];
 24278   for ( ; glyph < end; glyph++)
 24279     glyph[-n] = *glyph;
 24280 }
 24281 
 24282 /* Find the positions in a bidi-reordered ROW to serve as ROW->minpos
 24283    and ROW->maxpos.  */
 24284 static void
 24285 find_row_edges (struct it *it, struct glyph_row *row,
 24286                 ptrdiff_t min_pos, ptrdiff_t min_bpos,
 24287                 ptrdiff_t max_pos, ptrdiff_t max_bpos)
 24288 {
 24289   /* FIXME: Revisit this when glyph ``spilling'' in continuation
 24290      lines' rows is implemented for bidi-reordered rows.  */
 24291 
 24292   /* ROW->minpos is the value of min_pos, the minimal buffer position
 24293      we have in ROW, or ROW->start.pos if that is smaller.  */
 24294   if (min_pos <= ZV && min_pos < row->start.pos.charpos)
 24295     SET_TEXT_POS (row->minpos, min_pos, min_bpos);
 24296   else
 24297     /* We didn't find buffer positions smaller than ROW->start, or
 24298        didn't find _any_ valid buffer positions in any of the glyphs,
 24299        so we must trust the iterator's computed positions.  */
 24300       row->minpos = row->start.pos;
 24301   if (max_pos <= 0)
 24302     {
 24303       max_pos = CHARPOS (it->current.pos);
 24304       max_bpos = BYTEPOS (it->current.pos);
 24305     }
 24306 
 24307   /* Here are the various use-cases for ending the row, and the
 24308      corresponding values for ROW->maxpos:
 24309 
 24310      Line ends in a newline from buffer       eol_pos + 1
 24311      Line is continued from buffer            max_pos + 1
 24312      Line is truncated on right               it->current.pos
 24313      Line ends in a newline from string       max_pos + 1(*)
 24314       (*) + 1 only when line ends in a forward scan
 24315      Line is continued from string            max_pos
 24316      Line is continued from display vector    max_pos
 24317      Line is entirely from a string           min_pos == max_pos
 24318      Line is entirely from a display vector   min_pos == max_pos
 24319      Line that ends at ZV                     ZV
 24320 
 24321      If you discover other use-cases, please add them here as
 24322      appropriate.  */
 24323   if (row->ends_at_zv_p)
 24324     row->maxpos = it->current.pos;
 24325   else if (row->used[TEXT_AREA])
 24326     {
 24327       bool seen_this_string = false;
 24328       struct glyph_row *r1 = row - 1;
 24329 
 24330       /* Did we see the same display string on the previous row?  */
 24331       if (STRINGP (it->object)
 24332           /* this is not the first row */
 24333           && row > it->w->desired_matrix->rows
 24334           /* previous row is not the header line or tab-line */
 24335           && !r1->mode_line_p
 24336           /* previous row also ends in a newline from a string */
 24337           && r1->ends_in_newline_from_string_p)
 24338         {
 24339           struct glyph *start, *end;
 24340 
 24341           /* Search for the last glyph of the previous row that came
 24342              from buffer or string.  Depending on whether the row is
 24343              L2R or R2L, we need to process it front to back or the
 24344              other way round.  */
 24345           if (!r1->reversed_p)
 24346             {
 24347               start = r1->glyphs[TEXT_AREA];
 24348               end = start + r1->used[TEXT_AREA];
 24349               /* Glyphs inserted by redisplay have nil as their object.  */
 24350               while (end > start
 24351                      && NILP ((end - 1)->object)
 24352                      && (end - 1)->charpos <= 0)
 24353                 --end;
 24354               if (end > start)
 24355                 {
 24356                   if (EQ ((end - 1)->object, it->object))
 24357                     seen_this_string = true;
 24358                 }
 24359               else
 24360                 /* If all the glyphs of the previous row were inserted
 24361                    by redisplay, it means the previous row was
 24362                    produced from a single newline, which is only
 24363                    possible if that newline came from the same string
 24364                    as the one which produced this ROW.  */
 24365                 seen_this_string = true;
 24366             }
 24367           else
 24368             {
 24369               end = r1->glyphs[TEXT_AREA] - 1;
 24370               start = end + r1->used[TEXT_AREA];
 24371               while (end < start
 24372                      && NILP ((end + 1)->object)
 24373                      && (end + 1)->charpos <= 0)
 24374                 ++end;
 24375               if (end < start)
 24376                 {
 24377                   if (EQ ((end + 1)->object, it->object))
 24378                     seen_this_string = true;
 24379                 }
 24380               else
 24381                 seen_this_string = true;
 24382             }
 24383         }
 24384       /* Take note of each display string that covers a newline only
 24385          once, the first time we see it.  This is for when a display
 24386          string includes more than one newline in it.  */
 24387       if (row->ends_in_newline_from_string_p && !seen_this_string)
 24388         {
 24389           /* If we were scanning the buffer forward when we displayed
 24390              the string, we want to account for at least one buffer
 24391              position that belongs to this row (position covered by
 24392              the display string), so that cursor positioning will
 24393              consider this row as a candidate when point is at the end
 24394              of the visual line represented by this row.  This is not
 24395              required when scanning back, because max_pos will already
 24396              have a much larger value.  */
 24397           if (CHARPOS (row->end.pos) > max_pos)
 24398             inc_both (&max_pos, &max_bpos);
 24399           SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
 24400         }
 24401       else if (CHARPOS (it->eol_pos) > 0)
 24402         SET_TEXT_POS (row->maxpos,
 24403                       CHARPOS (it->eol_pos) + 1, BYTEPOS (it->eol_pos) + 1);
 24404       else if (row->continued_p)
 24405         {
 24406           /* If max_pos is different from IT's current position, it
 24407              means IT->method does not belong to the display element
 24408              at max_pos.  However, it also means that the display
 24409              element at max_pos was displayed in its entirety on this
 24410              line, which is equivalent to saying that the next line
 24411              starts at the next buffer position.  */
 24412           if (IT_CHARPOS (*it) == max_pos && it->method != GET_FROM_BUFFER)
 24413             SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
 24414           else
 24415             {
 24416               inc_both (&max_pos, &max_bpos);
 24417               SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
 24418             }
 24419         }
 24420       else if (row->truncated_on_right_p)
 24421         /* display_line already called reseat_at_next_visible_line_start,
 24422            which puts the iterator at the beginning of the next line, in
 24423            the logical order. */
 24424         row->maxpos = it->current.pos;
 24425       else if (max_pos == min_pos && it->method != GET_FROM_BUFFER)
 24426         /* A line that is entirely from a string/image/stretch...  */
 24427         row->maxpos = row->minpos;
 24428       else
 24429         emacs_abort ();
 24430     }
 24431   else
 24432     row->maxpos = it->current.pos;
 24433 }
 24434 
 24435 /* Like display_count_lines, but capable of counting outside of the
 24436    current narrowed region.  */
 24437 static ptrdiff_t
 24438 display_count_lines_logically (ptrdiff_t start_byte, ptrdiff_t limit_byte,
 24439                                ptrdiff_t count, ptrdiff_t *byte_pos_ptr)
 24440 {
 24441   if (!display_line_numbers_widen || (BEGV == BEG && ZV == Z))
 24442     return display_count_lines (start_byte, limit_byte, count, byte_pos_ptr);
 24443 
 24444   ptrdiff_t val;
 24445   specpdl_ref pdl_count = SPECPDL_INDEX ();
 24446   record_unwind_protect (save_restriction_restore, save_restriction_save ());
 24447   labeled_restrictions_remove_in_current_buffer ();
 24448   Fwiden ();
 24449   val = display_count_lines (start_byte, limit_byte, count, byte_pos_ptr);
 24450   unbind_to (pdl_count, Qnil);
 24451   return val;
 24452 }
 24453 
 24454 /* Count the number of screen lines in window IT->w between character
 24455    position IT_CHARPOS(*IT) and the line showing that window's point.  */
 24456 static ptrdiff_t
 24457 display_count_lines_visually (struct it *it)
 24458 {
 24459   struct it tem_it;
 24460   ptrdiff_t to;
 24461   struct text_pos from;
 24462 
 24463   /* If we already calculated a relative line number, use that.  This
 24464      trick relies on the fact that visual lines (a.k.a. "glyph rows")
 24465      are laid out sequentially, one by one, for each sequence of calls
 24466      to display_line or other similar function that follows a call to
 24467      init_iterator.  */
 24468   if (it->lnum_bytepos > 0)
 24469     return it->lnum + 1;
 24470   else
 24471     {
 24472       specpdl_ref count = SPECPDL_INDEX ();
 24473 
 24474       if (IT_CHARPOS (*it) <= PT)
 24475         {
 24476           from = it->current.pos;
 24477           to = PT;
 24478         }
 24479       else
 24480         {
 24481           SET_TEXT_POS (from, PT, PT_BYTE);
 24482           to = IT_CHARPOS (*it);
 24483         }
 24484       /* Need to disable visual mode temporarily, since otherwise the
 24485          call to move_it_to below and inside start_display will cause
 24486          infinite recursion.  */
 24487       specbind (Qdisplay_line_numbers, Qrelative);
 24488       start_display (&tem_it, it->w, from);
 24489       /* Some redisplay optimizations could invoke us very far from
 24490          PT, which will make the caller painfully slow.  There should
 24491          be no need to go too far beyond the window's bottom, as any
 24492          such optimization will fail to show point anyway.  */
 24493       move_it_to (&tem_it, to, -1,
 24494                   tem_it.last_visible_y
 24495                   + (SCROLL_LIMIT + 10) * FRAME_LINE_HEIGHT (tem_it.f),
 24496                   -1, MOVE_TO_POS | MOVE_TO_Y);
 24497       unbind_to (count, Qnil);
 24498       return IT_CHARPOS (*it) <= PT ? -tem_it.vpos : tem_it.vpos;
 24499     }
 24500 }
 24501 
 24502 /* Produce the line-number glyphs for the current glyph_row.  If
 24503    IT->glyph_row is non-NULL, populate the row with the produced
 24504    glyphs.  */
 24505 static void
 24506 maybe_produce_line_number (struct it *it)
 24507 {
 24508   ptrdiff_t last_line = it->lnum;
 24509   ptrdiff_t start_from, bytepos;
 24510   ptrdiff_t this_line;
 24511   bool first_time = false;
 24512   ptrdiff_t beg_byte;
 24513   ptrdiff_t z_byte;
 24514   bool line_numbers_wide;
 24515   void *itdata = bidi_shelve_cache ();
 24516 
 24517   if (display_line_numbers_offset
 24518       && !display_line_numbers_widen
 24519       && !EQ (Vdisplay_line_numbers, Qvisual)
 24520       && !EQ (Vdisplay_line_numbers, Qrelative))
 24521     line_numbers_wide = true;
 24522   else
 24523     line_numbers_wide = display_line_numbers_widen;
 24524 
 24525   beg_byte = line_numbers_wide ? BEG_BYTE : BEGV_BYTE;
 24526   z_byte = line_numbers_wide ? Z_BYTE : ZV_BYTE;
 24527 
 24528   if (EQ (Vdisplay_line_numbers, Qvisual))
 24529     this_line = display_count_lines_visually (it);
 24530   else
 24531     {
 24532       if (!last_line)
 24533         {
 24534           /* If possible, reuse data cached by line-number-mode.  */
 24535           if (it->w->base_line_number > 0
 24536               && it->w->base_line_pos > 0
 24537               && it->w->base_line_pos <= IT_CHARPOS (*it)
 24538               /* line-number-mode always displays narrowed line
 24539                  numbers, so we cannot use its data if the user wants
 24540                  line numbers that disregard narrowing, or if the
 24541                  buffer's narrowing has just changed.  */
 24542               && !(line_numbers_wide
 24543                    && (BEG_BYTE != BEGV_BYTE || Z_BYTE != ZV_BYTE))
 24544               && !current_buffer->clip_changed)
 24545             {
 24546               start_from = CHAR_TO_BYTE (it->w->base_line_pos);
 24547               last_line = it->w->base_line_number - 1;
 24548             }
 24549           else
 24550             start_from = beg_byte;
 24551           if (!it->lnum_bytepos)
 24552             first_time = true;
 24553         }
 24554       else
 24555         start_from = it->lnum_bytepos;
 24556 
 24557       /* Paranoia: what if someone changes the narrowing since the
 24558          last time display_line was called?  Shouldn't really happen,
 24559          but who knows what some crazy Lisp invoked by :eval could do?  */
 24560       if (!(beg_byte <= start_from && start_from <= z_byte))
 24561         {
 24562           last_line = 0;
 24563           start_from = beg_byte;
 24564         }
 24565 
 24566       this_line =
 24567         last_line + display_count_lines_logically (start_from,
 24568                                                    IT_BYTEPOS (*it),
 24569                                                    IT_CHARPOS (*it), &bytepos);
 24570       eassert (this_line > 0 || (this_line == 0 && start_from == beg_byte));
 24571       eassert (bytepos == IT_BYTEPOS (*it));
 24572     }
 24573 
 24574   /* Record the line number information.  */
 24575   if (this_line != last_line || !it->lnum_bytepos)
 24576     {
 24577       it->lnum = this_line;
 24578       it->lnum_bytepos = IT_BYTEPOS (*it);
 24579     }
 24580 
 24581   /* Produce the glyphs for the line number.  */
 24582   struct it tem_it;
 24583   char lnum_buf[INT_STRLEN_BOUND (ptrdiff_t) + 1];
 24584   bool beyond_zv = IT_BYTEPOS (*it) >= ZV_BYTE ? true : false;
 24585   ptrdiff_t lnum_offset = -1; /* to produce 1-based line numbers */
 24586   int lnum_face_id = merge_faces (it->w, Qline_number, 0, DEFAULT_FACE_ID);
 24587   int current_lnum_face_id
 24588     = merge_faces (it->w, Qline_number_current_line, 0, DEFAULT_FACE_ID);
 24589   /* From here onwards, we must prevent freeing realized faces, because
 24590      we are using the above 2 face IDs for the glyphs we produce.  */
 24591   bool save_free_realized_faces = inhibit_free_realized_faces;
 24592   inhibit_free_realized_faces = true;
 24593   /* Compute point's line number if needed.  */
 24594   if ((EQ (Vdisplay_line_numbers, Qrelative)
 24595        || EQ (Vdisplay_line_numbers, Qvisual)
 24596        || lnum_face_id != current_lnum_face_id)
 24597       && !it->pt_lnum)
 24598     {
 24599       ptrdiff_t ignored;
 24600       if (PT_BYTE > it->lnum_bytepos && !EQ (Vdisplay_line_numbers, Qvisual))
 24601         it->pt_lnum =
 24602           this_line + display_count_lines_logically (it->lnum_bytepos, PT_BYTE,
 24603                                                      PT, &ignored);
 24604       else
 24605         it->pt_lnum = display_count_lines_logically (beg_byte, PT_BYTE, PT,
 24606                                                      &ignored);
 24607     }
 24608   /* Compute the required width if needed.  */
 24609   if (!it->lnum_width)
 24610     {
 24611       if (FIXNATP (Vdisplay_line_numbers_width))
 24612         it->lnum_width = XFIXNAT (Vdisplay_line_numbers_width);
 24613 
 24614       /* Max line number to be displayed cannot be more than the one
 24615          corresponding to the last row of the desired matrix.  */
 24616       ptrdiff_t max_lnum;
 24617 
 24618       if (NILP (Vdisplay_line_numbers_current_absolute)
 24619           && (EQ (Vdisplay_line_numbers, Qrelative)
 24620               || EQ (Vdisplay_line_numbers, Qvisual)))
 24621         /* We subtract one more because the current line is always
 24622            zero in this mode.  */
 24623         max_lnum = it->w->desired_matrix->nrows - 2;
 24624       else if (EQ (Vdisplay_line_numbers, Qvisual))
 24625         max_lnum = it->pt_lnum + it->w->desired_matrix->nrows - 1;
 24626       else
 24627         max_lnum = this_line + it->w->desired_matrix->nrows - 1 - it->vpos;
 24628       max_lnum = max (1, max_lnum);
 24629       it->lnum_width = max (it->lnum_width, log10 (max_lnum) + 1);
 24630       eassert (it->lnum_width > 0);
 24631     }
 24632   if (EQ (Vdisplay_line_numbers, Qrelative))
 24633     lnum_offset = it->pt_lnum;
 24634   else if (EQ (Vdisplay_line_numbers, Qvisual))
 24635     lnum_offset = 0;
 24636   else if (display_line_numbers_offset)
 24637     lnum_offset -= display_line_numbers_offset;
 24638 
 24639   /* Under 'relative', display the absolute line number for the
 24640      current line, unless the user requests otherwise.  */
 24641   ptrdiff_t lnum_to_display = eabs (this_line - lnum_offset);
 24642   if ((EQ (Vdisplay_line_numbers, Qrelative)
 24643        || EQ (Vdisplay_line_numbers, Qvisual))
 24644       && lnum_to_display == 0
 24645       && !NILP (Vdisplay_line_numbers_current_absolute))
 24646     lnum_to_display = it->pt_lnum + 1;
 24647   /* In L2R rows we need to append the blank separator, in R2L
 24648      rows we need to prepend it.  But this function is usually
 24649      called when no display elements were produced from the
 24650      following line, so the paragraph direction might be unknown.
 24651      Therefore we cheat and add 2 blanks, one on either side.  */
 24652   pint2str (lnum_buf, it->lnum_width + 1, lnum_to_display);
 24653   strcat (lnum_buf, " ");
 24654 
 24655   /* Setup for producing the glyphs.  */
 24656   init_iterator (&tem_it, it->w, -1, -1, &scratch_glyph_row,
 24657                  /* FIXME: Use specialized face.  */
 24658                  DEFAULT_FACE_ID);
 24659   scratch_glyph_row.reversed_p = false;
 24660   scratch_glyph_row.used[TEXT_AREA] = 0;
 24661   SET_TEXT_POS (tem_it.position, 0, 0);
 24662   tem_it.avoid_cursor_p = true;
 24663   tem_it.bidi_p = true;
 24664   tem_it.bidi_it.type = WEAK_EN;
 24665   /* According to UAX#9, EN goes up 2 levels in L2R paragraph and
 24666      1 level in R2L paragraphs.  Emulate that, assuming we are in
 24667      an L2R paragraph.  */
 24668   tem_it.bidi_it.resolved_level = 2;
 24669 
 24670   /* We must leave space for 2 glyphs for continuation and truncation,
 24671      and at least one glyph for buffer text.  */
 24672   int width_limit =
 24673     tem_it.last_visible_x - tem_it.first_visible_x
 24674     - 3 * FRAME_COLUMN_WIDTH (it->f);
 24675 
 24676   tem_it.face_id = lnum_face_id;
 24677   /* Avoid displaying any face other than line-number on
 24678      empty lines beyond EOB.  */
 24679   if (lnum_face_id != current_lnum_face_id
 24680       && (EQ (Vdisplay_line_numbers, Qvisual)
 24681           ? this_line == 0
 24682           : this_line == it->pt_lnum)
 24683       && it->what != IT_EOB)
 24684     tem_it.face_id = current_lnum_face_id;
 24685   else if (!beyond_zv)
 24686     {
 24687       if (display_line_numbers_major_tick > 0
 24688           && (lnum_to_display % display_line_numbers_major_tick == 0))
 24689         tem_it.face_id = merge_faces (it->w, Qline_number_major_tick,
 24690                                       0, DEFAULT_FACE_ID);
 24691       else if (display_line_numbers_minor_tick > 0
 24692                && (lnum_to_display % display_line_numbers_minor_tick == 0))
 24693         tem_it.face_id = merge_faces (it->w, Qline_number_minor_tick,
 24694                                       0, DEFAULT_FACE_ID);
 24695     }
 24696 
 24697   /* Produce glyphs for the line number in a scratch glyph_row.  */
 24698   for (const char *p = lnum_buf; *p; p++)
 24699     {
 24700       /* For continuation lines and lines after ZV, instead of a line
 24701          number, produce a blank prefix of the same width.  */
 24702       if (beyond_zv
 24703           /* Don't display the same line number more than once.  */
 24704           || (!EQ (Vdisplay_line_numbers, Qvisual)
 24705               && (it->continuation_lines_width > 0
 24706                   || (this_line == last_line && !first_time))))
 24707         tem_it.c = tem_it.char_to_display = ' ';
 24708       else
 24709         tem_it.c = tem_it.char_to_display = *p;
 24710       tem_it.len = 1;
 24711       /* Make sure these glyphs will have a "position" of -1.  */
 24712       SET_TEXT_POS (tem_it.position, -1, -1);
 24713       PRODUCE_GLYPHS (&tem_it);
 24714 
 24715       /* Stop producing glyphs, and refrain from producing the line
 24716          number, if we don't have enough space on this line.  */
 24717       if (tem_it.current_x >= width_limit)
 24718         {
 24719           it->lnum_width = 0;
 24720           it->lnum_pixel_width = 0;
 24721           bidi_unshelve_cache (itdata, false);
 24722           inhibit_free_realized_faces = save_free_realized_faces;
 24723           return;
 24724         }
 24725     }
 24726 
 24727   inhibit_free_realized_faces = save_free_realized_faces;
 24728 
 24729   /* Record the width in pixels we need for the line number display.  */
 24730   it->lnum_pixel_width = tem_it.current_x;
 24731   /* Copy the produced glyphs into IT's glyph_row.  */
 24732   struct glyph *g = scratch_glyph_row.glyphs[TEXT_AREA];
 24733   struct glyph *e = g + scratch_glyph_row.used[TEXT_AREA];
 24734   struct glyph *p = it->glyph_row ? it->glyph_row->glyphs[TEXT_AREA] : NULL;
 24735   short *u = it->glyph_row ? &it->glyph_row->used[TEXT_AREA] : NULL;
 24736 
 24737   eassert (it->glyph_row == NULL || it->glyph_row->used[TEXT_AREA] == 0);
 24738 
 24739   for ( ; g < e; g++)
 24740     {
 24741       it->current_x += g->pixel_width;
 24742       /* The following is important when this function is called
 24743          from move_it_in_display_line_to: HPOS is incremented only
 24744          when we are in the visible portion of the glyph row.  */
 24745       if (it->current_x > it->first_visible_x)
 24746         it->hpos++;
 24747       if (p)
 24748         {
 24749           *p++ = *g;
 24750           (*u)++;
 24751         }
 24752     }
 24753 
 24754   /* Update IT's metrics due to glyphs produced for line numbers.
 24755      Don't do that for rows beyond ZV, to avoid displaying a cursor of
 24756      different dimensions there.  */
 24757   if (!beyond_zv)
 24758     {
 24759       if (it->glyph_row)
 24760         {
 24761           struct glyph_row *row = it->glyph_row;
 24762 
 24763           it->max_ascent = max (row->ascent, tem_it.max_ascent);
 24764           it->max_descent = max (row->height - row->ascent, tem_it.max_descent);
 24765           it->max_phys_ascent = max (row->phys_ascent, tem_it.max_phys_ascent);
 24766           it->max_phys_descent = max (row->phys_height - row->phys_ascent,
 24767                                       tem_it.max_phys_descent);
 24768         }
 24769       else
 24770         {
 24771           it->max_ascent = max (it->max_ascent, tem_it.max_ascent);
 24772           it->max_descent = max (it->max_descent, tem_it.max_descent);
 24773           it->max_phys_ascent = max (it->max_phys_ascent,
 24774                                      tem_it.max_phys_ascent);
 24775           it->max_phys_descent = max (it->max_phys_descent,
 24776                                       tem_it.max_phys_descent);
 24777         }
 24778     }
 24779 
 24780   it->line_number_produced_p = true;
 24781 
 24782   bidi_unshelve_cache (itdata, false);
 24783 }
 24784 
 24785 /* Return true if this glyph row needs a line number to be produced
 24786    for it.  */
 24787 static bool
 24788 should_produce_line_number (struct it *it)
 24789 {
 24790   if (NILP (Vdisplay_line_numbers))
 24791     return false;
 24792 
 24793   /* Don't display line numbers in minibuffer windows.  */
 24794   if (MINI_WINDOW_P (it->w))
 24795     return false;
 24796 
 24797 #ifdef HAVE_WINDOW_SYSTEM
 24798   /* Don't display line number in tooltip frames.  */
 24799   if (FRAME_TOOLTIP_P (XFRAME (WINDOW_FRAME (it->w))))
 24800     return false;
 24801 #endif
 24802 
 24803   /* If the character at current position has a non-nil special
 24804      property, disable line numbers for this row.  This is for
 24805      packages such as company-mode, which need this for their tricky
 24806      layout, where line numbers get in the way.  */
 24807   Lisp_Object val = Fget_char_property (make_fixnum (IT_CHARPOS (*it)),
 24808                                         Qdisplay_line_numbers_disable,
 24809                                         it->window);
 24810   /* For ZV, we need to also look in empty overlays at that point,
 24811      because get-char-property always returns nil for ZV, except if
 24812      the property is in 'default-text-properties'.  */
 24813   if (NILP (val) && IT_CHARPOS (*it) >= ZV)
 24814     val = disable_line_numbers_overlay_at_eob ();
 24815   return NILP (val) ? true : false;
 24816 }
 24817 
 24818 /* Return true if ROW has no glyphs except those inserted by the
 24819    display engine.  This is needed for indicate-empty-lines and
 24820    similar features when the glyph row starts with glyphs which didn't
 24821    come from buffer or string.  */
 24822 static bool
 24823 row_text_area_empty (struct glyph_row *row)
 24824 {
 24825   if (!row->reversed_p)
 24826     {
 24827       for (struct glyph *g = row->glyphs[TEXT_AREA];
 24828            g < row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
 24829            g++)
 24830         if (!NILP (g->object) || g->charpos > 0)
 24831           return false;
 24832     }
 24833   else
 24834     {
 24835       for (struct glyph *g = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
 24836            g > row->glyphs[TEXT_AREA];
 24837            g--)
 24838         if (!NILP ((g - 1)->object) || (g - 1)->charpos > 0)
 24839           return false;
 24840     }
 24841 
 24842   return true;
 24843 }
 24844 
 24845 /* Construct the glyph row IT->glyph_row in the desired matrix of
 24846    IT->w from text at the current position of IT.  See dispextern.h
 24847    for an overview of struct it.  Value is true if
 24848    IT->glyph_row displays text, as opposed to a line displaying ZV
 24849    only.  CURSOR_VPOS is the window-relative vertical position of
 24850    the glyph row displaying the cursor, or -1 if unknown.  */
 24851 
 24852 static bool
 24853 display_line (struct it *it, int cursor_vpos)
 24854 {
 24855   struct glyph_row *row = it->glyph_row;
 24856   Lisp_Object overlay_arrow_string;
 24857   struct it wrap_it;
 24858   void *wrap_data = NULL;
 24859   bool may_wrap = false;
 24860   int wrap_x UNINIT;
 24861   int wrap_row_used = -1;
 24862   int wrap_row_ascent UNINIT, wrap_row_height UNINIT;
 24863   int wrap_row_phys_ascent UNINIT, wrap_row_phys_height UNINIT;
 24864   int wrap_row_extra_line_spacing UNINIT;
 24865   ptrdiff_t wrap_row_min_pos UNINIT, wrap_row_min_bpos UNINIT;
 24866   ptrdiff_t wrap_row_max_pos UNINIT, wrap_row_max_bpos UNINIT;
 24867   int cvpos;
 24868   ptrdiff_t min_pos = ZV + 1, max_pos = 0;
 24869   ptrdiff_t min_bpos UNINIT, max_bpos UNINIT;
 24870   bool pending_handle_line_prefix = false;
 24871   int tab_line = window_wants_tab_line (it->w);
 24872   int header_line = window_wants_header_line (it->w);
 24873   bool hscroll_this_line = (cursor_vpos >= 0
 24874                             && it->vpos == cursor_vpos - tab_line - header_line
 24875                             && hscrolling_current_line_p (it->w));
 24876   int first_visible_x = it->first_visible_x;
 24877   int last_visible_x = it->last_visible_x;
 24878   int x_incr = 0;
 24879 
 24880   /* We always start displaying at hpos zero even if hscrolled.  */
 24881   eassert (it->hpos == 0 && it->current_x == 0);
 24882 
 24883   if (MATRIX_ROW_VPOS (row, it->w->desired_matrix)
 24884       >= it->w->desired_matrix->nrows)
 24885     {
 24886       it->w->nrows_scale_factor++;
 24887       it->f->fonts_changed = true;
 24888       return false;
 24889     }
 24890 
 24891   /* Clear the result glyph row and enable it.  */
 24892   prepare_desired_row (it->w, row, false);
 24893 
 24894   row->y = it->current_y;
 24895   row->start = it->start;
 24896   row->continuation_lines_width = it->continuation_lines_width;
 24897   row->displays_text_p = true;
 24898   row->starts_in_middle_of_char_p = it->starts_in_middle_of_char_p;
 24899   it->starts_in_middle_of_char_p = false;
 24900   it->stretch_adjust = 0;
 24901   it->line_number_produced_p = false;
 24902 
 24903   /* If we are going to display the cursor's line, account for the
 24904      hscroll of that line.  We subtract the window's min_hscroll,
 24905      because that was already accounted for in init_iterator.  */
 24906   if (hscroll_this_line)
 24907     x_incr =
 24908       (window_hscroll_limited (it->w, it->f) - it->w->min_hscroll)
 24909       * FRAME_COLUMN_WIDTH (it->f);
 24910 
 24911   bool line_number_needed = should_produce_line_number (it);
 24912 
 24913   /* Move over display elements that are not visible because we are
 24914      hscrolled.  This may stop at an x-position < first_visible_x
 24915      if the first glyph is partially visible or if we hit a line end.  */
 24916   if (it->current_x < it->first_visible_x + x_incr)
 24917     {
 24918       enum move_it_result move_result;
 24919 
 24920       this_line_min_pos = row->start.pos;
 24921       if (hscroll_this_line)
 24922         {
 24923           it->first_visible_x += x_incr;
 24924           it->last_visible_x  += x_incr;
 24925         }
 24926       if (current_buffer->long_line_optimizations_p
 24927           && it->line_wrap == TRUNCATE
 24928           && window_hscroll_limited (it->w, it->f) > large_hscroll_threshold)
 24929         {
 24930           /* Special optimization for very long and truncated lines
 24931              which are hscrolled far to the left: jump directly to the
 24932              (approximate) position that is visible, instead of slowly
 24933              walking there.  */
 24934           ptrdiff_t chars_to_skip =
 24935             it->first_visible_x / FRAME_COLUMN_WIDTH (it->f);
 24936           move_result = fast_move_it_horizontally (it, chars_to_skip);
 24937 
 24938           if (move_result == MOVE_X_REACHED)
 24939             it->current_x = it->first_visible_x;
 24940           else  /* use arbitrary value < first_visible_x */
 24941             it->current_x = it->first_visible_x - FRAME_COLUMN_WIDTH (it->f);
 24942         }
 24943       else
 24944         move_result = move_it_in_display_line_to (it, ZV, it->first_visible_x,
 24945                                                   MOVE_TO_POS | MOVE_TO_X);
 24946       /* If we are under a large hscroll, move_it_in_display_line_to
 24947          could hit the end of the line without reaching
 24948          first_visible_x.  Pretend that we did reach it.  This is
 24949          especially important on a TTY, where we will call
 24950          extend_face_to_end_of_line, which needs to know how many
 24951          blank glyphs to produce.  */
 24952       if (it->current_x < it->first_visible_x
 24953           && (move_result == MOVE_NEWLINE_OR_CR
 24954               || move_result == MOVE_POS_MATCH_OR_ZV))
 24955         it->current_x = it->first_visible_x;
 24956 
 24957       /* In case move_it_in_display_line_to above "produced" the line
 24958          number.  */
 24959       it->line_number_produced_p = false;
 24960 
 24961       /* Record the smallest positions seen while we moved over
 24962          display elements that are not visible.  This is needed by
 24963          redisplay_internal for optimizing the case where the cursor
 24964          stays inside the same line.  The rest of this function only
 24965          considers positions that are actually displayed, so
 24966          RECORD_MAX_MIN_POS will not otherwise record positions that
 24967          are hscrolled to the left of the left edge of the window.  */
 24968       min_pos = CHARPOS (this_line_min_pos);
 24969       min_bpos = BYTEPOS (this_line_min_pos);
 24970 
 24971       /* Produce line number, if needed.  */
 24972       if (line_number_needed)
 24973         maybe_produce_line_number (it);
 24974     }
 24975   else if (it->area == TEXT_AREA)
 24976     {
 24977       /* Line numbers should precede the line-prefix or wrap-prefix.  */
 24978       if (line_number_needed)
 24979         maybe_produce_line_number (it);
 24980 
 24981       /* We only do this when not calling move_it_in_display_line_to
 24982          above, because that function calls itself handle_line_prefix.  */
 24983       handle_line_prefix (it);
 24984     }
 24985   else
 24986     {
 24987       /* Line-prefix and wrap-prefix are always displayed in the text
 24988          area.  But if this is the first call to display_line after
 24989          init_iterator, the iterator might have been set up to write
 24990          into a marginal area, e.g. if the line begins with some
 24991          display property that writes to the margins.  So we need to
 24992          wait with the call to handle_line_prefix until whatever
 24993          writes to the margin has done its job.  */
 24994       pending_handle_line_prefix = true;
 24995     }
 24996 
 24997   /* Get the initial row height.  This is either the height of the
 24998      text hscrolled, if there is any, or zero.  */
 24999   row->ascent = it->max_ascent;
 25000   row->height = it->max_ascent + it->max_descent;
 25001   row->phys_ascent = it->max_phys_ascent;
 25002   row->phys_height = it->max_phys_ascent + it->max_phys_descent;
 25003   row->extra_line_spacing = it->max_extra_line_spacing;
 25004 
 25005 /* Utility macro to record max and min buffer positions seen until now.  */
 25006 #define RECORD_MAX_MIN_POS(IT)                                  \
 25007   do                                                            \
 25008     {                                                           \
 25009       bool composition_p                                        \
 25010         = !STRINGP ((IT)->string) && ((IT)->what == IT_COMPOSITION); \
 25011       ptrdiff_t current_pos =                                   \
 25012         composition_p ? (IT)->cmp_it.charpos                    \
 25013                       : IT_CHARPOS (*(IT));                     \
 25014       ptrdiff_t current_bpos =                                  \
 25015         composition_p ? CHAR_TO_BYTE (current_pos)              \
 25016                       : IT_BYTEPOS (*(IT));                     \
 25017       if (current_pos < min_pos)                                \
 25018         {                                                       \
 25019           min_pos = current_pos;                                \
 25020           min_bpos = current_bpos;                              \
 25021         }                                                       \
 25022       if (IT_CHARPOS (*it) > max_pos)                           \
 25023         {                                                       \
 25024           max_pos = IT_CHARPOS (*it);                           \
 25025           max_bpos = IT_BYTEPOS (*it);                          \
 25026         }                                                       \
 25027     }                                                           \
 25028   while (false)
 25029 
 25030   /* Loop generating characters.  The loop is left with IT on the next
 25031      character to display.  */
 25032   while (true)
 25033     {
 25034       int n_glyphs_before, hpos_before, x_before;
 25035       int x, nglyphs;
 25036       int ascent = 0, descent = 0, phys_ascent = 0, phys_descent = 0;
 25037 
 25038       /* Retrieve the next thing to display.  Value is false if end of
 25039          buffer reached.  */
 25040       if (!get_next_display_element (it))
 25041         {
 25042           bool row_has_glyphs = false;
 25043           /* Maybe add a space at the end of this line that is used to
 25044              display the cursor there under X.  Set the charpos of the
 25045              first glyph of blank lines not corresponding to any text
 25046              to -1.  */
 25047           if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 25048             row->exact_window_width_line_p = true;
 25049           else if ((append_space_for_newline (it, true)
 25050                     && row->used[TEXT_AREA] == 1)
 25051                    || row->used[TEXT_AREA] == 0
 25052                    || (row_has_glyphs = row_text_area_empty (row)))
 25053             {
 25054               row->glyphs[TEXT_AREA]->charpos = -1;
 25055               /* Don't reset the displays_text_p flag if we are
 25056                  displaying line numbers or line-prefix.  */
 25057               if (!row_has_glyphs)
 25058                 row->displays_text_p = false;
 25059 
 25060               if (!NILP (BVAR (XBUFFER (it->w->contents), indicate_empty_lines))
 25061                   && (!MINI_WINDOW_P (it->w)))
 25062                 row->indicate_empty_line_p = true;
 25063             }
 25064 
 25065           it->continuation_lines_width = 0;
 25066           /* Reset those iterator values set from display property
 25067              values.  This is for the case when the display property
 25068              ends at ZV, and is not a replacing property, so pop_it is
 25069              not called.  */
 25070           it->font_height = Qnil;
 25071           it->voffset = 0;
 25072           row->ends_at_zv_p = true;
 25073           /* A row that displays right-to-left text must always have
 25074              its last face extended all the way to the end of line,
 25075              even if this row ends in ZV, because we still write to
 25076              the screen left to right.  We also need to extend the
 25077              last face if the default face is remapped to some
 25078              different face, otherwise the functions that clear
 25079              portions of the screen will clear with the default face's
 25080              background color.  */
 25081           if (row->reversed_p
 25082               || lookup_basic_face (it->w, it->f, DEFAULT_FACE_ID)
 25083               != DEFAULT_FACE_ID)
 25084             extend_face_to_end_of_line (it);
 25085           break;
 25086         }
 25087 
 25088       /* Now, get the metrics of what we want to display.  This also
 25089          generates glyphs in `row' (which is IT->glyph_row).  */
 25090       n_glyphs_before = row->used[TEXT_AREA];
 25091       x = it->current_x;
 25092 
 25093       /* Remember the line height so far in case the next element doesn't
 25094          fit on the line.  */
 25095       if (it->line_wrap != TRUNCATE)
 25096         {
 25097           ascent = it->max_ascent;
 25098           descent = it->max_descent;
 25099           phys_ascent = it->max_phys_ascent;
 25100           phys_descent = it->max_phys_descent;
 25101 
 25102           if (it->line_wrap == WORD_WRAP && it->area == TEXT_AREA)
 25103             {
 25104               bool next_may_wrap = may_wrap;
 25105               /* Can we wrap after this character?  */
 25106               if (char_can_wrap_after (it))
 25107                 next_may_wrap = true;
 25108               else
 25109                 next_may_wrap = false;
 25110               /* Can we wrap here? */
 25111               if (may_wrap && char_can_wrap_before (it))
 25112                 {
 25113                   SAVE_IT (wrap_it, *it, wrap_data);
 25114                   wrap_x = x;
 25115                   wrap_row_used = row->used[TEXT_AREA];
 25116                   wrap_row_ascent = row->ascent;
 25117                   wrap_row_height = row->height;
 25118                   wrap_row_phys_ascent = row->phys_ascent;
 25119                   wrap_row_phys_height = row->phys_height;
 25120                   wrap_row_extra_line_spacing = row->extra_line_spacing;
 25121                   wrap_row_min_pos = min_pos;
 25122                   wrap_row_min_bpos = min_bpos;
 25123                   wrap_row_max_pos = max_pos;
 25124                   wrap_row_max_bpos = max_bpos;
 25125                 }
 25126               /* Update may_wrap for the next iteration.  */
 25127               may_wrap = next_may_wrap;
 25128             }
 25129         }
 25130 
 25131       PRODUCE_GLYPHS (it);
 25132 
 25133       /* If this display element was in marginal areas, continue with
 25134          the next one.  */
 25135       if (it->area != TEXT_AREA)
 25136         {
 25137           row->ascent = max (row->ascent, it->max_ascent);
 25138           row->height = max (row->height, it->max_ascent + it->max_descent);
 25139           row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
 25140           row->phys_height = max (row->phys_height,
 25141                                   it->max_phys_ascent + it->max_phys_descent);
 25142           row->extra_line_spacing = max (row->extra_line_spacing,
 25143                                          it->max_extra_line_spacing);
 25144           set_iterator_to_next (it, true);
 25145           /* If we didn't handle the line/wrap prefix above, and the
 25146              call to set_iterator_to_next just switched to TEXT_AREA,
 25147              process the prefix now.  */
 25148           if (it->area == TEXT_AREA && pending_handle_line_prefix)
 25149             {
 25150               /* Line numbers should precede the line-prefix or wrap-prefix.  */
 25151               if (line_number_needed)
 25152                 maybe_produce_line_number (it);
 25153 
 25154               pending_handle_line_prefix = false;
 25155               handle_line_prefix (it);
 25156             }
 25157           continue;
 25158         }
 25159 
 25160       /* Does the display element fit on the line?  If we truncate
 25161          lines, we should draw past the right edge of the window.  If
 25162          we don't truncate, we want to stop so that we can display the
 25163          continuation glyph before the right margin.  If lines are
 25164          continued, there are two possible strategies for characters
 25165          resulting in more than 1 glyph (e.g. tabs): Display as many
 25166          glyphs as possible in this line and leave the rest for the
 25167          continuation line, or display the whole element in the next
 25168          line.  Original redisplay did the former, so we do it also.  */
 25169       nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
 25170       hpos_before = it->hpos;
 25171       x_before = x;
 25172 
 25173       if (/* Not a newline.  */
 25174           nglyphs > 0
 25175           /* Glyphs produced fit entirely in the line.  */
 25176           && it->current_x < it->last_visible_x)
 25177         {
 25178           it->hpos += nglyphs;
 25179           row->ascent = max (row->ascent, it->max_ascent);
 25180           row->height = max (row->height, it->max_ascent + it->max_descent);
 25181           row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
 25182           row->phys_height = max (row->phys_height,
 25183                                   it->max_phys_ascent + it->max_phys_descent);
 25184           row->extra_line_spacing = max (row->extra_line_spacing,
 25185                                          it->max_extra_line_spacing);
 25186           if (it->current_x - it->pixel_width < it->first_visible_x
 25187               /* When line numbers are displayed, row->x should not be
 25188                  offset, as the first glyph after the line number can
 25189                  never be partially visible.  */
 25190               && !line_number_needed
 25191               /* In R2L rows, we arrange in extend_face_to_end_of_line
 25192                  to add a right offset to the line, by a suitable
 25193                  change to the stretch glyph that is the leftmost
 25194                  glyph of the line.  */
 25195               && !row->reversed_p)
 25196             row->x = x - it->first_visible_x;
 25197           /* Record the maximum and minimum buffer positions seen so
 25198              far in glyphs that will be displayed by this row.  */
 25199           if (it->bidi_p)
 25200             RECORD_MAX_MIN_POS (it);
 25201         }
 25202       else
 25203         {
 25204           int i, new_x;
 25205           struct glyph *glyph;
 25206 
 25207           for (i = 0; i < nglyphs; ++i, x = new_x)
 25208             {
 25209               /* Identify the glyphs added by the last call to
 25210                  PRODUCE_GLYPHS.  In R2L rows, they are prepended to
 25211                  the previous glyphs.  */
 25212               if (!row->reversed_p)
 25213                 glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
 25214               else
 25215                 glyph = row->glyphs[TEXT_AREA] + nglyphs - 1 - i;
 25216               new_x = x + glyph->pixel_width;
 25217 
 25218               if (/* Lines are continued.  */
 25219                   it->line_wrap != TRUNCATE
 25220                   && (/* Glyph doesn't fit on the line.  */
 25221                       new_x > it->last_visible_x
 25222                       /* Or it fits exactly on a window system frame.  */
 25223                       || (new_x == it->last_visible_x
 25224                           && FRAME_WINDOW_P (it->f)
 25225                           && (row->reversed_p
 25226                               ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25227                               : WINDOW_RIGHT_FRINGE_WIDTH (it->w)))))
 25228                 {
 25229                   /* End of a continued line.  */
 25230 
 25231                   if (it->hpos == 0
 25232                       || (new_x == it->last_visible_x
 25233                           && FRAME_WINDOW_P (it->f)
 25234                           && (row->reversed_p
 25235                               ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25236                               : WINDOW_RIGHT_FRINGE_WIDTH (it->w))))
 25237                     {
 25238                       /* Current glyph is the only one on the line or
 25239                          fits exactly on the line.  We must continue
 25240                          the line because we can't draw the cursor
 25241                          after the glyph.  */
 25242                       row->continued_p = true;
 25243                       it->current_x = new_x;
 25244                       it->continuation_lines_width += new_x;
 25245                       ++it->hpos;
 25246                       if (i == nglyphs - 1)
 25247                         {
 25248                           /* If line-wrap is on, check if a previous
 25249                              wrap point was found.  */
 25250                           if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it)
 25251                               && wrap_row_used > 0 /* Found.  */
 25252                               /* Even if there is a previous wrap
 25253                                  point, continue the line here as
 25254                                  usual, if (i) the previous character
 25255                                  allows wrapping after it, AND (ii)
 25256                                  the current character allows wrapping
 25257                                  before it.  Because this is a valid
 25258                                  break point, we can just continue to
 25259                                  the next line at here, there is no
 25260                                  need to wrap early at the previous
 25261                                  wrap point.  */
 25262                               && (!may_wrap || !char_can_wrap_before (it)))
 25263                             goto back_to_wrap;
 25264 
 25265                           /* Record the maximum and minimum buffer
 25266                              positions seen so far in glyphs that will be
 25267                              displayed by this row.  */
 25268                           if (it->bidi_p)
 25269                             RECORD_MAX_MIN_POS (it);
 25270                           set_iterator_to_next (it, true);
 25271                           if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 25272                             {
 25273                               if (!get_next_display_element (it))
 25274                                 {
 25275                                   row->exact_window_width_line_p = true;
 25276                                   it->continuation_lines_width = 0;
 25277                                   it->font_height = Qnil;
 25278                                   it->voffset = 0;
 25279                                   row->continued_p = false;
 25280                                   row->ends_at_zv_p = true;
 25281                                 }
 25282                               else if (ITERATOR_AT_END_OF_LINE_P (it))
 25283                                 {
 25284                                   row->continued_p = false;
 25285                                   row->exact_window_width_line_p = true;
 25286                                 }
 25287                               /* If line-wrap is on, check if a
 25288                                  previous wrap point was found.  */
 25289                               else if (wrap_row_used > 0
 25290                                        /* Even if there is a previous
 25291                                           wrap point, continue the
 25292                                           line here as usual, if (i)
 25293                                           the previous character was a
 25294                                           space or tab AND (ii) the
 25295                                           current character is not,
 25296                                           AND (iii) the current
 25297                                           character allows wrapping
 25298                                           before it.  */
 25299                                        && (!may_wrap || !char_can_wrap_before (it)))
 25300                                 goto back_to_wrap;
 25301 
 25302                             }
 25303                         }
 25304                       else if (it->bidi_p)
 25305                         RECORD_MAX_MIN_POS (it);
 25306                       if (WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 25307                           || WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0)
 25308                         extend_face_to_end_of_line (it);
 25309                     }
 25310                   else if (CHAR_GLYPH_PADDING_P (*glyph)
 25311                            && !FRAME_WINDOW_P (it->f))
 25312                     {
 25313                       /* A padding glyph that doesn't fit on this line.
 25314                          This means the whole character doesn't fit
 25315                          on the line.  */
 25316                       if (row->reversed_p)
 25317                         unproduce_glyphs (it, row->used[TEXT_AREA]
 25318                                                - n_glyphs_before);
 25319                       row->used[TEXT_AREA] = n_glyphs_before;
 25320 
 25321                       /* Fill the rest of the row with continuation
 25322                          glyphs like in 20.x.  */
 25323                       while (row->glyphs[TEXT_AREA] + row->used[TEXT_AREA]
 25324                              < row->glyphs[1 + TEXT_AREA])
 25325                         produce_special_glyphs (it, IT_CONTINUATION);
 25326 
 25327                       row->continued_p = true;
 25328                       it->current_x = x_before;
 25329                       it->continuation_lines_width += x_before;
 25330 
 25331                       /* Restore the height to what it was before the
 25332                          element not fitting on the line.  */
 25333                       it->max_ascent = ascent;
 25334                       it->max_descent = descent;
 25335                       it->max_phys_ascent = phys_ascent;
 25336                       it->max_phys_descent = phys_descent;
 25337                       if (WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 25338                           || WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0)
 25339                         extend_face_to_end_of_line (it);
 25340                     }
 25341                   else if (wrap_row_used > 0)
 25342                     {
 25343                     back_to_wrap:
 25344                       if (row->reversed_p)
 25345                         unproduce_glyphs (it,
 25346                                           row->used[TEXT_AREA] - wrap_row_used);
 25347                       RESTORE_IT (it, &wrap_it, wrap_data);
 25348                       it->continuation_lines_width += wrap_x;
 25349                       row->used[TEXT_AREA] = wrap_row_used;
 25350                       row->ascent = wrap_row_ascent;
 25351                       row->height = wrap_row_height;
 25352                       row->phys_ascent = wrap_row_phys_ascent;
 25353                       row->phys_height = wrap_row_phys_height;
 25354                       row->extra_line_spacing = wrap_row_extra_line_spacing;
 25355                       min_pos = wrap_row_min_pos;
 25356                       min_bpos = wrap_row_min_bpos;
 25357                       max_pos = wrap_row_max_pos;
 25358                       max_bpos = wrap_row_max_bpos;
 25359                       row->continued_p = true;
 25360                       row->ends_at_zv_p = false;
 25361                       row->exact_window_width_line_p = false;
 25362 
 25363                       /* Make sure that a non-default face is extended
 25364                          up to the right margin of the window.  */
 25365                       extend_face_to_end_of_line (it);
 25366                     }
 25367                   else if ((it->what == IT_CHARACTER
 25368                             || it->what == IT_STRETCH
 25369                             || it->what == IT_COMPOSITION)
 25370                            && it->c == '\t' && FRAME_WINDOW_P (it->f))
 25371                     {
 25372                       /* A TAB that extends past the right edge of the
 25373                          window.  This produces a single glyph on
 25374                          window system frames.  We leave the glyph in
 25375                          this row and let it fill the row, but don't
 25376                          consume the TAB.  */
 25377                       if ((row->reversed_p
 25378                            ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25379                            : WINDOW_RIGHT_FRINGE_WIDTH (it->w)) == 0)
 25380                         produce_special_glyphs (it, IT_CONTINUATION);
 25381                       it->continuation_lines_width += it->last_visible_x;
 25382                       row->ends_in_middle_of_char_p = true;
 25383                       row->continued_p = true;
 25384                       glyph->pixel_width = it->last_visible_x - x;
 25385                       it->starts_in_middle_of_char_p = true;
 25386                       if (WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 25387                           || WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0)
 25388                         extend_face_to_end_of_line (it);
 25389                     }
 25390                   else
 25391                     {
 25392                       /* Something other than a TAB that draws past
 25393                          the right edge of the window.  Restore
 25394                          positions to values before the element.  */
 25395                       if (row->reversed_p)
 25396                         unproduce_glyphs (it, row->used[TEXT_AREA]
 25397                                                - (n_glyphs_before + i));
 25398                       row->used[TEXT_AREA] = n_glyphs_before + i;
 25399 
 25400                       /* Display continuation glyphs.  */
 25401                       it->current_x = x_before;
 25402                       it->continuation_lines_width += x;
 25403                       if (!FRAME_WINDOW_P (it->f)
 25404                           || (row->reversed_p
 25405                               ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25406                               : WINDOW_RIGHT_FRINGE_WIDTH (it->w)) == 0)
 25407                         produce_special_glyphs (it, IT_CONTINUATION);
 25408                       row->continued_p = true;
 25409 
 25410                       extend_face_to_end_of_line (it);
 25411 
 25412                       if (nglyphs > 1 && i > 0)
 25413                         {
 25414                           row->ends_in_middle_of_char_p = true;
 25415                           it->starts_in_middle_of_char_p = true;
 25416                         }
 25417 
 25418                       /* Restore the height to what it was before the
 25419                          element not fitting on the line.  */
 25420                       it->max_ascent = ascent;
 25421                       it->max_descent = descent;
 25422                       it->max_phys_ascent = phys_ascent;
 25423                       it->max_phys_descent = phys_descent;
 25424                     }
 25425 
 25426                   break;
 25427                 }
 25428               else if (new_x > it->first_visible_x)
 25429                 {
 25430                   /* Increment number of glyphs actually displayed.  */
 25431                   ++it->hpos;
 25432 
 25433                   /* Record the maximum and minimum buffer positions
 25434                      seen so far in glyphs that will be displayed by
 25435                      this row.  */
 25436                   if (it->bidi_p)
 25437                     RECORD_MAX_MIN_POS (it);
 25438 
 25439                   if (x < it->first_visible_x && !row->reversed_p
 25440                       && !line_number_needed)
 25441                     /* Glyph is partially visible, i.e. row starts at
 25442                        negative X position.  Don't do that in R2L
 25443                        rows, where we arrange to add a right offset to
 25444                        the line in extend_face_to_end_of_line, by a
 25445                        suitable change to the stretch glyph that is
 25446                        the leftmost glyph of the line.  */
 25447                     row->x = x - it->first_visible_x;
 25448                   /* When the last glyph of an R2L row only fits
 25449                      partially on the line, we need to set row->x to a
 25450                      negative offset, so that the leftmost glyph is
 25451                      the one that is partially visible.  But if we are
 25452                      going to produce the truncation glyph, this will
 25453                      be taken care of in produce_special_glyphs.  */
 25454                   if (row->reversed_p
 25455                       && new_x > it->last_visible_x
 25456                       && !line_number_needed
 25457                       && !(it->line_wrap == TRUNCATE
 25458                            && WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0))
 25459                     {
 25460                       eassert (FRAME_WINDOW_P (it->f));
 25461                       row->x = it->last_visible_x - new_x;
 25462                     }
 25463                 }
 25464               else
 25465                 {
 25466                   /* Glyph is completely off the left margin of the
 25467                      window.  This should not happen because of the
 25468                      move_it_in_display_line at the start of this
 25469                      function, unless the text display area of the
 25470                      window is empty.  */
 25471                   eassert (it->first_visible_x <= it->last_visible_x);
 25472                 }
 25473             }
 25474           /* Even if this display element produced no glyphs at all,
 25475              we want to record its position.  */
 25476           if (it->bidi_p && nglyphs == 0)
 25477             RECORD_MAX_MIN_POS (it);
 25478 
 25479           row->ascent = max (row->ascent, it->max_ascent);
 25480           row->height = max (row->height, it->max_ascent + it->max_descent);
 25481           row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
 25482           row->phys_height = max (row->phys_height,
 25483                                   it->max_phys_ascent + it->max_phys_descent);
 25484           row->extra_line_spacing = max (row->extra_line_spacing,
 25485                                          it->max_extra_line_spacing);
 25486 
 25487           /* End of this display line if row is continued.  */
 25488           if (row->continued_p || row->ends_at_zv_p)
 25489             break;
 25490         }
 25491 
 25492     at_end_of_line:
 25493       /* Is this a line end?  If yes, we're also done, after making
 25494          sure that a non-default face is extended up to the right
 25495          margin of the window.  */
 25496       if (ITERATOR_AT_END_OF_LINE_P (it))
 25497         {
 25498           int used_before = row->used[TEXT_AREA];
 25499 
 25500           row->ends_in_newline_from_string_p = STRINGP (it->object);
 25501 
 25502           /* Add a space at the end of the line that is used to
 25503              display the cursor there.  */
 25504           if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 25505             append_space_for_newline (it, false);
 25506 
 25507           /* Extend the face to the end of the line.  */
 25508           extend_face_to_end_of_line (it);
 25509 
 25510           /* Make sure we have the position.  */
 25511           if (used_before == 0)
 25512             row->glyphs[TEXT_AREA]->charpos = CHARPOS (it->position);
 25513 
 25514           /* Record the position of the newline, for use in
 25515              find_row_edges.  */
 25516           it->eol_pos = it->current.pos;
 25517 
 25518           /* Consume the line end.  This skips over invisible lines.  */
 25519           set_iterator_to_next (it, true);
 25520           it->continuation_lines_width = 0;
 25521           break;
 25522         }
 25523 
 25524       /* Detect overly-wide wrap-prefixes made of (space ...) display
 25525          properties.  When such a wrap prefix reaches past the right
 25526          margin of the window, we need to avoid the call to
 25527          set_iterator_to_next below, so that it->line_wrap is left at
 25528          its TRUNCATE value wisely set by handle_line_prefix.
 25529          Otherwise, set_iterator_to_next will pop the iterator stack,
 25530          restore it->line_wrap, and redisplay might infloop.  */
 25531       bool overwide_wrap_prefix =
 25532         CONSP (it->object) && EQ (XCAR (it->object), Qspace)
 25533         && it->sp > 0 && it->method == GET_FROM_STRETCH
 25534         && it->current_x >= it->last_visible_x
 25535         && it->continuation_lines_width > 0
 25536         && it->line_wrap == TRUNCATE && it->stack[0].line_wrap != TRUNCATE;
 25537 
 25538       /* Proceed with next display element.  Note that this skips
 25539          over lines invisible because of selective display.  */
 25540       if (!overwide_wrap_prefix)
 25541         set_iterator_to_next (it, true);
 25542 
 25543       /* If we truncate lines, we are done when the last displayed
 25544          glyphs reach past the right margin of the window.  */
 25545       if (it->line_wrap == TRUNCATE
 25546           && ((FRAME_WINDOW_P (it->f)
 25547                /* Images are preprocessed in produce_image_glyph such
 25548                   that they are cropped at the right edge of the
 25549                   window, so an image glyph will always end exactly at
 25550                   last_visible_x, even if there's no right fringe.  */
 25551                && ((row->reversed_p
 25552                     ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25553                     : WINDOW_RIGHT_FRINGE_WIDTH (it->w))
 25554                    || it->what == IT_IMAGE))
 25555               ? (it->current_x >= it->last_visible_x)
 25556               : (it->current_x > it->last_visible_x)))
 25557         {
 25558           /* Maybe add truncation glyphs.  */
 25559           if (!FRAME_WINDOW_P (it->f)
 25560               || (row->reversed_p
 25561                   ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25562                   : WINDOW_RIGHT_FRINGE_WIDTH (it->w)) == 0)
 25563             {
 25564               int i, n;
 25565 
 25566               if (!row->reversed_p)
 25567                 {
 25568                   for (i = row->used[TEXT_AREA] - 1; i > 0; --i)
 25569                     if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
 25570                       break;
 25571                 }
 25572               else
 25573                 {
 25574                   for (i = 0; i < row->used[TEXT_AREA]; i++)
 25575                     if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
 25576                       break;
 25577                   /* Remove any padding glyphs at the front of ROW, to
 25578                      make room for the truncation glyphs we will be
 25579                      adding below.  The loop below always inserts at
 25580                      least one truncation glyph, so also remove the
 25581                      last glyph added to ROW.  */
 25582                   unproduce_glyphs (it, i + 1);
 25583                   /* Adjust i for the loop below.  */
 25584                   i = row->used[TEXT_AREA] - (i + 1);
 25585                 }
 25586 
 25587               /* produce_special_glyphs overwrites the last glyph, so
 25588                  we don't want that if we want to keep that last
 25589                  glyph, which means it's an image.  */
 25590               if (it->current_x > it->last_visible_x)
 25591                 {
 25592                   it->current_x = x_before;
 25593                   if (!FRAME_WINDOW_P (it->f))
 25594                     {
 25595                       for (n = row->used[TEXT_AREA]; i < n; ++i)
 25596                         {
 25597                           row->used[TEXT_AREA] = i;
 25598                           produce_special_glyphs (it, IT_TRUNCATION);
 25599                         }
 25600                     }
 25601                   else
 25602                     {
 25603                       row->used[TEXT_AREA] = i;
 25604                       produce_special_glyphs (it, IT_TRUNCATION);
 25605                     }
 25606                   it->hpos = hpos_before;
 25607                 }
 25608             }
 25609           else if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 25610             {
 25611               /* Don't truncate if we can overflow newline into fringe.  */
 25612               if (!get_next_display_element (it))
 25613                 {
 25614                   it->continuation_lines_width = 0;
 25615                   it->font_height = Qnil;
 25616                   it->voffset = 0;
 25617                   row->ends_at_zv_p = true;
 25618                   row->exact_window_width_line_p = true;
 25619                   break;
 25620                 }
 25621               if (ITERATOR_AT_END_OF_LINE_P (it))
 25622                 {
 25623                   row->exact_window_width_line_p = true;
 25624                   goto at_end_of_line;
 25625                 }
 25626               it->current_x = x_before;
 25627               it->hpos = hpos_before;
 25628             }
 25629 
 25630           row->truncated_on_right_p = true;
 25631           it->continuation_lines_width = 0;
 25632           reseat_at_next_visible_line_start (it, false);
 25633           /* We insist below that IT's position be at ZV because in
 25634              bidi-reordered lines the character at visible line start
 25635              might not be the character that follows the newline in
 25636              the logical order.  */
 25637           if (IT_BYTEPOS (*it) > BEG_BYTE)
 25638             row->ends_at_zv_p =
 25639               IT_BYTEPOS (*it) >= ZV_BYTE
 25640               && (ZV_BYTE <= 1 || FETCH_BYTE (ZV_BYTE - 1) != '\n');
 25641           else
 25642             row->ends_at_zv_p = false;
 25643           break;
 25644         }
 25645     }
 25646 
 25647   if (wrap_data)
 25648     bidi_unshelve_cache (wrap_data, true);
 25649 
 25650   /* If line is not empty and hscrolled, maybe insert truncation glyphs
 25651      at the left window margin.  */
 25652   if (it->first_visible_x
 25653       && IT_CHARPOS (*it) != CHARPOS (row->start.pos))
 25654     {
 25655       if (!FRAME_WINDOW_P (it->f)
 25656           || (((row->reversed_p
 25657                 ? WINDOW_RIGHT_FRINGE_WIDTH (it->w)
 25658                 : WINDOW_LEFT_FRINGE_WIDTH (it->w)) == 0)
 25659               /* Don't let insert_left_trunc_glyphs overwrite the
 25660                  first glyph of the row if it is an image.  */
 25661               && row->glyphs[TEXT_AREA]->type != IMAGE_GLYPH))
 25662         insert_left_trunc_glyphs (it);
 25663       row->truncated_on_left_p = true;
 25664     }
 25665 
 25666   /* Remember the position at which this line ends.
 25667 
 25668      BIDI Note: any code that needs MATRIX_ROW_START/END_CHARPOS
 25669      cannot be before the call to find_row_edges below, since that is
 25670      where these positions are determined. */
 25671   row->end = it->current;
 25672   if (!it->bidi_p)
 25673     {
 25674       row->minpos = row->start.pos;
 25675       row->maxpos = row->end.pos;
 25676     }
 25677   else
 25678     {
 25679       /* ROW->minpos and ROW->maxpos must be the smallest and
 25680          `1 + the largest' buffer positions in ROW.  But if ROW was
 25681          bidi-reordered, these two positions can be anywhere in the
 25682          row, so we must determine them now.  */
 25683       find_row_edges (it, row, min_pos, min_bpos, max_pos, max_bpos);
 25684     }
 25685 
 25686   /* If the start of this line is the overlay arrow-position, then
 25687      mark this glyph row as the one containing the overlay arrow.
 25688      This is clearly a mess with variable size fonts.  It would be
 25689      better to let it be displayed like cursors under X.  */
 25690   if ((MATRIX_ROW_DISPLAYS_TEXT_P (row) || !overlay_arrow_seen)
 25691       && (overlay_arrow_string = overlay_arrow_at_row (it, row),
 25692           !NILP (overlay_arrow_string)))
 25693     {
 25694       /* Overlay arrow in window redisplay is a fringe bitmap.  */
 25695       if (STRINGP (overlay_arrow_string))
 25696         {
 25697           struct glyph_row *arrow_row
 25698             = get_overlay_arrow_glyph_row (it->w, overlay_arrow_string);
 25699           struct glyph *glyph = arrow_row->glyphs[TEXT_AREA];
 25700           struct glyph *arrow_end = glyph + arrow_row->used[TEXT_AREA];
 25701           struct glyph *p = row->glyphs[TEXT_AREA];
 25702           struct glyph *p2, *end;
 25703 
 25704           /* Copy the arrow glyphs.  */
 25705           while (glyph < arrow_end)
 25706             *p++ = *glyph++;
 25707 
 25708           /* Throw away padding glyphs.  */
 25709           p2 = p;
 25710           end = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
 25711           while (p2 < end && CHAR_GLYPH_PADDING_P (*p2))
 25712             ++p2;
 25713           if (p2 > p)
 25714             {
 25715               while (p2 < end)
 25716                 *p++ = *p2++;
 25717               row->used[TEXT_AREA] = p2 - row->glyphs[TEXT_AREA];
 25718             }
 25719         }
 25720       else
 25721         {
 25722           eassert (FIXNUMP (overlay_arrow_string));
 25723           row->overlay_arrow_bitmap = XFIXNUM (overlay_arrow_string);
 25724         }
 25725       overlay_arrow_seen = true;
 25726     }
 25727 
 25728   /* Highlight trailing whitespace.  */
 25729   if (!NILP (Vshow_trailing_whitespace))
 25730     highlight_trailing_whitespace (it);
 25731 
 25732   /* Compute pixel dimensions of this line.  */
 25733   compute_line_metrics (it);
 25734 
 25735   /* Implementation note: No changes in the glyphs of ROW or in their
 25736      faces can be done past this point, because compute_line_metrics
 25737      computes ROW's hash value and stores it within the glyph_row
 25738      structure.  */
 25739 
 25740   /* Record whether this row ends inside an ellipsis.  */
 25741   row->ends_in_ellipsis_p
 25742     = (it->method == GET_FROM_DISPLAY_VECTOR
 25743        && it->ellipsis_p);
 25744 
 25745   /* Save fringe bitmaps in this row.  */
 25746   row->left_user_fringe_bitmap = it->left_user_fringe_bitmap;
 25747   row->left_user_fringe_face_id = it->left_user_fringe_face_id;
 25748   row->right_user_fringe_bitmap = it->right_user_fringe_bitmap;
 25749   row->right_user_fringe_face_id = it->right_user_fringe_face_id;
 25750 
 25751   it->left_user_fringe_bitmap = 0;
 25752   it->left_user_fringe_face_id = 0;
 25753   it->right_user_fringe_bitmap = 0;
 25754   it->right_user_fringe_face_id = 0;
 25755 
 25756   /* When they turn off tooltip-mode on a GUI frame, we call 'message'
 25757      with message-truncate-lines bound to non-nil, which produces
 25758      truncation bitmaps on the fringe.  Force redrawing of the fringes
 25759      in that case, to make sure the fringe bitmaps are removed when a
 25760      shorter message is displayed.  */
 25761   if (MINI_WINDOW_P (it->w) && it->line_wrap == TRUNCATE
 25762       && FRAME_WINDOW_P (it->f) && !cursor_in_echo_area)
 25763     row->redraw_fringe_bitmaps_p = true;
 25764 
 25765   /* Maybe set the cursor.  */
 25766   cvpos = it->w->cursor.vpos;
 25767   if ((cvpos < 0
 25768        /* In bidi-reordered rows, keep checking for proper cursor
 25769           position even if one has been found already, because buffer
 25770           positions in such rows change non-linearly with ROW->VPOS,
 25771           when a line is continued.  One exception: when we are at ZV,
 25772           display cursor on the first suitable glyph row, since all
 25773           the empty rows after that also have their position set to ZV.  */
 25774        /* FIXME: Revisit this when glyph ``spilling'' in continuation
 25775           lines' rows is implemented for bidi-reordered rows.  */
 25776        || (it->bidi_p
 25777            && !MATRIX_ROW (it->w->desired_matrix, cvpos)->ends_at_zv_p))
 25778       && PT >= MATRIX_ROW_START_CHARPOS (row)
 25779       && PT <= MATRIX_ROW_END_CHARPOS (row)
 25780       && cursor_row_p (row))
 25781     set_cursor_from_row (it->w, row, it->w->desired_matrix, 0, 0, 0, 0);
 25782 
 25783   /* Prepare for the next line.  This line starts horizontally at (X
 25784      HPOS) = (0 0).  Vertical positions are incremented.  As a
 25785      convenience for the caller, IT->glyph_row is set to the next
 25786      row to be used.  */
 25787   it->current_x = it->hpos = 0;
 25788   it->current_y += row->height;
 25789   /* Restore the first and last visible X if we adjusted them for
 25790      current-line hscrolling.  */
 25791   if (hscroll_this_line)
 25792     {
 25793       it->first_visible_x = first_visible_x;
 25794       it->last_visible_x  = last_visible_x;
 25795     }
 25796   SET_TEXT_POS (it->eol_pos, 0, 0);
 25797   ++it->vpos;
 25798   ++it->glyph_row;
 25799   /* The next row should by default use the same value of the
 25800      reversed_p flag as this one.  set_iterator_to_next decides when
 25801      it's a new paragraph, and PRODUCE_GLYPHS recomputes the value of
 25802      the flag accordingly.  */
 25803   if (it->glyph_row < MATRIX_BOTTOM_TEXT_ROW (it->w->desired_matrix, it->w))
 25804     it->glyph_row->reversed_p = row->reversed_p;
 25805   it->start = row->end;
 25806   return MATRIX_ROW_DISPLAYS_TEXT_P (row);
 25807 
 25808 #undef RECORD_MAX_MIN_POS
 25809 }
 25810 
 25811 DEFUN ("current-bidi-paragraph-direction", Fcurrent_bidi_paragraph_direction,
 25812        Scurrent_bidi_paragraph_direction, 0, 1, 0,
 25813        doc: /* Return paragraph direction at point in BUFFER.
 25814 Value is either `left-to-right' or `right-to-left'.
 25815 If BUFFER is omitted or nil, it defaults to the current buffer.
 25816 
 25817 Paragraph direction determines how the text in the paragraph is displayed.
 25818 In left-to-right paragraphs, text begins at the left margin of the window
 25819 and the reading direction is generally left to right.  In right-to-left
 25820 paragraphs, text begins at the right margin and is read from right to left.
 25821 
 25822 See also `bidi-paragraph-direction'.  */)
 25823   (Lisp_Object buffer)
 25824 {
 25825   struct buffer *buf = current_buffer;
 25826   struct buffer *old = buf;
 25827 
 25828   if (! NILP (buffer))
 25829     {
 25830       CHECK_BUFFER (buffer);
 25831       buf = XBUFFER (buffer);
 25832     }
 25833 
 25834   if (NILP (BVAR (buf, bidi_display_reordering))
 25835       || NILP (BVAR (buf, enable_multibyte_characters))
 25836       /* When we are loading loadup.el, the character property tables
 25837          needed for bidi iteration are not yet available.  */
 25838       || redisplay__inhibit_bidi)
 25839     return Qleft_to_right;
 25840   else if (!NILP (BVAR (buf, bidi_paragraph_direction)))
 25841     return BVAR (buf, bidi_paragraph_direction);
 25842   else
 25843     {
 25844       /* Determine the direction from buffer text.  We could try to
 25845          use current_matrix if it is up to date, but this seems fast
 25846          enough as it is.  */
 25847       struct bidi_it itb;
 25848       ptrdiff_t pos = BUF_PT (buf);
 25849       ptrdiff_t bytepos = BUF_PT_BYTE (buf);
 25850       int c;
 25851       void *itb_data = bidi_shelve_cache ();
 25852 
 25853       set_buffer_temp (buf);
 25854       /* bidi_paragraph_init finds the base direction of the paragraph
 25855          by searching forward from paragraph start.  We need the base
 25856          direction of the current or _previous_ paragraph, so we need
 25857          to make sure we are within that paragraph.  To that end, find
 25858          the previous non-empty line.  */
 25859       if (pos >= ZV && pos > BEGV)
 25860         dec_both (&pos, &bytepos);
 25861       AUTO_STRING (trailing_white_space, "[\f\t ]*\n");
 25862       if (fast_looking_at (trailing_white_space,
 25863                            pos, bytepos, ZV, ZV_BYTE, Qnil) > 0)
 25864         {
 25865           while ((c = FETCH_BYTE (bytepos)) == '\n'
 25866                  || c == ' ' || c == '\t' || c == '\f')
 25867             {
 25868               if (bytepos <= BEGV_BYTE)
 25869                 break;
 25870               bytepos--;
 25871               pos--;
 25872             }
 25873           while (!CHAR_HEAD_P (FETCH_BYTE (bytepos)))
 25874             bytepos--;
 25875         }
 25876       bidi_init_it (pos, bytepos, FRAME_WINDOW_P (SELECTED_FRAME ()), &itb);
 25877       itb.paragraph_dir = NEUTRAL_DIR;
 25878       itb.string.s = NULL;
 25879       itb.string.lstring = Qnil;
 25880       itb.string.bufpos = 0;
 25881       itb.string.from_disp_str = false;
 25882       itb.string.unibyte = false;
 25883       /* We have no window to use here for ignoring window-specific
 25884          overlays.  Using NULL for window pointer will cause
 25885          compute_display_string_pos to use the current buffer.  */
 25886       itb.w = NULL;
 25887       bidi_paragraph_init (NEUTRAL_DIR, &itb, true);
 25888       bidi_unshelve_cache (itb_data, false);
 25889       set_buffer_temp (old);
 25890       switch (itb.paragraph_dir)
 25891         {
 25892         case L2R:
 25893           return Qleft_to_right;
 25894           break;
 25895         case R2L:
 25896           return Qright_to_left;
 25897           break;
 25898         default:
 25899           emacs_abort ();
 25900         }
 25901     }
 25902 }
 25903 
 25904 DEFUN ("bidi-find-overridden-directionality",
 25905        Fbidi_find_overridden_directionality,
 25906        Sbidi_find_overridden_directionality, 3, 4, 0,
 25907        doc: /* Return position between FROM and TO where directionality was overridden.
 25908 
 25909 This function returns the first character position in the specified
 25910 region of OBJECT where characters have their bidirectional
 25911 properties affected in a way that might make its text look confusingly
 25912 on display.  For example, characters whose `bidi-class' property is `L',
 25913 could be forced to display as `R' by a directional override, and
 25914 likewise characters whose `bidi-class' is `R' or `AL' that are
 25915 forced to display as `L'.
 25916 
 25917 If no such character is found, the function returns nil.
 25918 
 25919 OBJECT is a Lisp string or buffer to search for overridden
 25920 directionality, and defaults to the current buffer if nil.
 25921 OBJECT can also be a window, in which case the function will search
 25922 the buffer displayed in that window.  Passing the window instead of
 25923 a buffer is preferable when the buffer is displayed in some window,
 25924 because this function will then be able to correctly account for
 25925 window-specific overlays, which can affect the results.
 25926 
 25927 Optional argument BASE-DIR specifies the base paragraph directory
 25928 of the text.  It should be a symbol, either `left-to-right'
 25929 or `right-to-left', and defaults to `left-to-right'.
 25930 
 25931 Strong directional characters `L', `R', and `AL' can have their
 25932 intrinsic directionality overridden by directional override control
 25933 characters RLO (u+202E) and LRO (u+202D).  They can also have their
 25934 directionality affected by other formatting control characters: LRE
 25935 (u+202A), RLE (u+202B), LRI (u+2066), and RLI (u+2067).  See the
 25936 function `get-char-code-property' for a way to inquire about the
 25937 `bidi-class' property of a character.  Characters whose intrinsic
 25938 directionality is weak or neutral, such as numbers or punctuation
 25939 characters, can be forced to display in a very different place with
 25940 respect of its surrounding characters, so as to make the surrounding
 25941 text confuse the user regarding what the text says.
 25942 
 25943 Also see the `highlight-confusing-reorderings' function, which can be
 25944 useful in similar circumstances as this function.  */)
 25945   (Lisp_Object from, Lisp_Object to, Lisp_Object object, Lisp_Object base_dir)
 25946 {
 25947   struct buffer *buf = current_buffer;
 25948   struct buffer *old = buf;
 25949   struct window *w = NULL;
 25950   bool frame_window_p = FRAME_WINDOW_P (SELECTED_FRAME ());
 25951   struct bidi_it itb;
 25952   ptrdiff_t from_pos, to_pos, from_bpos;
 25953   void *itb_data;
 25954 
 25955   if (!NILP (object))
 25956     {
 25957       if (BUFFERP (object))
 25958         buf = XBUFFER (object);
 25959       else if (WINDOWP (object))
 25960         {
 25961           w = decode_live_window (object);
 25962           buf = XBUFFER (w->contents);
 25963           frame_window_p = FRAME_WINDOW_P (XFRAME (w->frame));
 25964         }
 25965       else
 25966         CHECK_STRING (object);
 25967     }
 25968 
 25969   if (STRINGP (object))
 25970     {
 25971       /* Characters in unibyte strings are always treated by bidi.c as
 25972          strong LTR.  */
 25973       if (!STRING_MULTIBYTE (object)
 25974           /* When we are loading loadup.el, the character property
 25975              tables needed for bidi iteration are not yet
 25976              available.  */
 25977           || redisplay__inhibit_bidi)
 25978         return Qnil;
 25979 
 25980       validate_subarray (object, from, to, SCHARS (object), &from_pos, &to_pos);
 25981       if (from_pos >= SCHARS (object))
 25982         return Qnil;
 25983 
 25984       /* Set up the bidi iterator.  */
 25985       itb_data = bidi_shelve_cache ();
 25986       itb.paragraph_dir = NEUTRAL_DIR;
 25987       itb.string.lstring = object;
 25988       itb.string.s = NULL;
 25989       itb.string.schars = SCHARS (object);
 25990       itb.string.bufpos = 0;
 25991       itb.string.from_disp_str = false;
 25992       itb.string.unibyte = false;
 25993       itb.w = w;
 25994       bidi_init_it (0, 0, frame_window_p, &itb);
 25995     }
 25996   else
 25997     {
 25998       /* Nothing this fancy can happen in unibyte buffers, or in a
 25999          buffer that disabled reordering, or if FROM is at EOB.  */
 26000       if (NILP (BVAR (buf, bidi_display_reordering))
 26001           || NILP (BVAR (buf, enable_multibyte_characters))
 26002           /* When we are loading loadup.el, the character property
 26003              tables needed for bidi iteration are not yet
 26004              available.  */
 26005           || redisplay__inhibit_bidi)
 26006         return Qnil;
 26007 
 26008       set_buffer_temp (buf);
 26009       validate_region (&from, &to);
 26010       from_pos = XFIXNUM (from);
 26011       to_pos = XFIXNUM (to);
 26012       if (from_pos >= ZV)
 26013         return Qnil;
 26014 
 26015       /* Set up the bidi iterator.  */
 26016       itb_data = bidi_shelve_cache ();
 26017       from_bpos = CHAR_TO_BYTE (from_pos);
 26018       if (from_pos == BEGV)
 26019         {
 26020           itb.charpos = BEGV;
 26021           itb.bytepos = BEGV_BYTE;
 26022         }
 26023       else if (FETCH_BYTE (from_bpos - 1) == '\n')
 26024         {
 26025           itb.charpos = from_pos;
 26026           itb.bytepos = from_bpos;
 26027         }
 26028       else
 26029         itb.charpos = find_newline_no_quit (from_pos, CHAR_TO_BYTE (from_pos),
 26030                                             -1, &itb.bytepos);
 26031       itb.paragraph_dir = NEUTRAL_DIR;
 26032       itb.string.s = NULL;
 26033       itb.string.lstring = Qnil;
 26034       itb.string.bufpos = 0;
 26035       itb.string.from_disp_str = false;
 26036       itb.string.unibyte = false;
 26037       itb.w = w;
 26038       bidi_init_it (itb.charpos, itb.bytepos, frame_window_p, &itb);
 26039     }
 26040 
 26041   ptrdiff_t found;
 26042   bidi_dir_t bdir = EQ (base_dir, Qright_to_left) ? R2L : L2R;
 26043   do {
 26044     bidi_paragraph_init (bdir, &itb, false);
 26045     while ((found = bidi_find_first_overridden (&itb)) < from_pos)
 26046       ;
 26047   } while (found == ZV && itb.ch == '\n' && itb.charpos < to_pos);
 26048 
 26049   bidi_unshelve_cache (itb_data, false);
 26050   set_buffer_temp (old);
 26051 
 26052   return (from_pos <= found && found < to_pos) ? make_fixnum (found) : Qnil;
 26053 }
 26054 
 26055 DEFUN ("move-point-visually", Fmove_point_visually,
 26056        Smove_point_visually, 1, 1, 0,
 26057        doc: /* Move point in the visual order in the specified DIRECTION.
 26058 DIRECTION can be 1, meaning move to the right, or -1, which moves to the
 26059 left.
 26060 
 26061 Value is the new character position of point.  */)
 26062   (Lisp_Object direction)
 26063 {
 26064   struct window *w = XWINDOW (selected_window);
 26065   struct buffer *b = XBUFFER (w->contents);
 26066   struct glyph_row *row;
 26067   int dir;
 26068   Lisp_Object paragraph_dir;
 26069 
 26070 #define ROW_GLYPH_NEWLINE_P(ROW,GLYPH)          \
 26071   (!(ROW)->continued_p                          \
 26072    && NILP ((GLYPH)->object)                    \
 26073    && (GLYPH)->type == CHAR_GLYPH               \
 26074    && (GLYPH)->u.ch == ' '                      \
 26075    && (GLYPH)->charpos >= 0                     \
 26076    && !(GLYPH)->avoid_cursor_p)
 26077 
 26078   CHECK_FIXNUM (direction);
 26079   dir = XFIXNUM (direction);
 26080   if (dir > 0)
 26081     dir = 1;
 26082   else
 26083     dir = -1;
 26084 
 26085   /* If current matrix is up-to-date, we can use the information
 26086      recorded in the glyphs, at least as long as the goal is on the
 26087      screen.  */
 26088   if (w->window_end_valid
 26089       && !windows_or_buffers_changed
 26090       && b
 26091       && !b->clip_changed
 26092       && !b->prevent_redisplay_optimizations_p
 26093       && !window_outdated (w)
 26094       /* We rely below on the cursor coordinates to be up to date, but
 26095          we cannot trust them if some command moved point since the
 26096          last complete redisplay.  */
 26097       && w->last_point == BUF_PT (b)
 26098       && w->cursor.vpos >= 0
 26099       && w->cursor.vpos < w->current_matrix->nrows
 26100       && (row = MATRIX_ROW (w->current_matrix, w->cursor.vpos))->enabled_p)
 26101     {
 26102       struct glyph *g = row->glyphs[TEXT_AREA];
 26103       struct glyph *e = dir > 0 ? g + row->used[TEXT_AREA] : g - 1;
 26104       struct glyph *gpt = g + w->cursor.hpos;
 26105 
 26106       for (g = gpt + dir; (dir > 0 ? g < e : g > e); g += dir)
 26107         {
 26108           if (BUFFERP (g->object) && g->charpos != PT)
 26109             {
 26110               SET_PT (g->charpos);
 26111               w->cursor.vpos = -1;
 26112               return make_fixnum (PT);
 26113             }
 26114           else if (!NILP (g->object) && !EQ (g->object, gpt->object))
 26115             {
 26116               ptrdiff_t new_pos;
 26117 
 26118               if (BUFFERP (gpt->object))
 26119                 {
 26120                   new_pos = PT;
 26121                   if ((gpt->resolved_level - row->reversed_p) % 2 == 0)
 26122                     new_pos += (row->reversed_p ? -dir : dir);
 26123                   else
 26124                     new_pos -= (row->reversed_p ? -dir : dir);
 26125                   new_pos = clip_to_bounds (BEGV, new_pos, ZV);
 26126                   /* If we didn't move, we've hit BEGV or ZV, so we
 26127                      need to signal a suitable error.  */
 26128                   if (new_pos == PT)
 26129                     break;
 26130                 }
 26131               else if (BUFFERP (g->object))
 26132                 new_pos = g->charpos;
 26133               else
 26134                 break;
 26135               SET_PT (new_pos);
 26136               w->cursor.vpos = -1;
 26137               return make_fixnum (PT);
 26138             }
 26139           else if (ROW_GLYPH_NEWLINE_P (row, g))
 26140             {
 26141               /* Glyphs inserted at the end of a non-empty line for
 26142                  positioning the cursor have zero charpos, so we must
 26143                  deduce the value of point by other means.  */
 26144               if (g->charpos > 0)
 26145                 SET_PT (g->charpos);
 26146               else if (row->ends_at_zv_p && PT != ZV)
 26147                 SET_PT (ZV);
 26148               else if (PT != MATRIX_ROW_END_CHARPOS (row) - 1)
 26149                 SET_PT (MATRIX_ROW_END_CHARPOS (row) - 1);
 26150               else
 26151                 break;
 26152               w->cursor.vpos = -1;
 26153               return make_fixnum (PT);
 26154             }
 26155         }
 26156       if (g == e || NILP (g->object))
 26157         {
 26158           if (row->truncated_on_left_p || row->truncated_on_right_p)
 26159             goto simulate_display;
 26160           if (!row->reversed_p)
 26161             row += dir;
 26162           else
 26163             row -= dir;
 26164           if (!(MATRIX_FIRST_TEXT_ROW (w->current_matrix) <= row
 26165                 && row < MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w)))
 26166             goto simulate_display;
 26167 
 26168           if (dir > 0)
 26169             {
 26170               if (row->reversed_p && !row->continued_p)
 26171                 {
 26172                   SET_PT (MATRIX_ROW_END_CHARPOS (row) - 1);
 26173                   w->cursor.vpos = -1;
 26174                   return make_fixnum (PT);
 26175                 }
 26176               g = row->glyphs[TEXT_AREA];
 26177               e = g + row->used[TEXT_AREA];
 26178               for ( ; g < e; g++)
 26179                 {
 26180                   if (BUFFERP (g->object)
 26181                       /* Empty lines have only one glyph, which stands
 26182                          for the newline, and whose charpos is the
 26183                          buffer position of the newline.  */
 26184                       || ROW_GLYPH_NEWLINE_P (row, g)
 26185                       /* When the buffer ends in a newline, the line at
 26186                          EOB also has one glyph, but its charpos is -1.  */
 26187                       || (row->ends_at_zv_p
 26188                           && !row->reversed_p
 26189                           && NILP (g->object)
 26190                           && g->type == CHAR_GLYPH
 26191                           && g->u.ch == ' '))
 26192                     {
 26193                       if (g->charpos > 0)
 26194                         SET_PT (g->charpos);
 26195                       else if (!row->reversed_p
 26196                                && row->ends_at_zv_p
 26197                                && PT != ZV)
 26198                         SET_PT (ZV);
 26199                       else
 26200                         continue;
 26201                       w->cursor.vpos = -1;
 26202                       return make_fixnum (PT);
 26203                     }
 26204                 }
 26205             }
 26206           else
 26207             {
 26208               if (!row->reversed_p && !row->continued_p)
 26209                 {
 26210                   SET_PT (MATRIX_ROW_END_CHARPOS (row) - 1);
 26211                   w->cursor.vpos = -1;
 26212                   return make_fixnum (PT);
 26213                 }
 26214               e = row->glyphs[TEXT_AREA];
 26215               g = e + row->used[TEXT_AREA] - 1;
 26216               for ( ; g >= e; g--)
 26217                 {
 26218                   if (BUFFERP (g->object)
 26219                       || (ROW_GLYPH_NEWLINE_P (row, g)
 26220                           && g->charpos > 0)
 26221                       /* Empty R2L lines on GUI frames have the buffer
 26222                          position of the newline stored in the stretch
 26223                          glyph.  */
 26224                       || g->type == STRETCH_GLYPH
 26225                       || (row->ends_at_zv_p
 26226                           && row->reversed_p
 26227                           && NILP (g->object)
 26228                           && g->type == CHAR_GLYPH
 26229                           && g->u.ch == ' '))
 26230                     {
 26231                       if (g->charpos > 0)
 26232                         SET_PT (g->charpos);
 26233                       else if (row->reversed_p
 26234                                && row->ends_at_zv_p
 26235                                && PT != ZV)
 26236                         SET_PT (ZV);
 26237                       else
 26238                         continue;
 26239                       w->cursor.vpos = -1;
 26240                       return make_fixnum (PT);
 26241                     }
 26242                 }
 26243             }
 26244         }
 26245     }
 26246 
 26247  simulate_display:
 26248 
 26249   /* If we wind up here, we failed to move by using the glyphs, so we
 26250      need to simulate display instead.  */
 26251 
 26252   if (b)
 26253     paragraph_dir = Fcurrent_bidi_paragraph_direction (w->contents);
 26254   else
 26255     paragraph_dir = Qleft_to_right;
 26256   if (EQ (paragraph_dir, Qright_to_left))
 26257     dir = -dir;
 26258   if (PT <= BEGV && dir < 0)
 26259     xsignal0 (Qbeginning_of_buffer);
 26260   else if (PT >= ZV && dir > 0)
 26261     xsignal0 (Qend_of_buffer);
 26262   else
 26263     {
 26264       struct text_pos pt;
 26265       struct it it;
 26266       int pt_x, target_x, pixel_width, pt_vpos;
 26267       bool at_eol_p;
 26268       bool overshoot_expected = false;
 26269       bool target_is_eol_p = false;
 26270       void *itdata = bidi_shelve_cache ();
 26271 
 26272       /* Setup the arena.  */
 26273       SET_TEXT_POS (pt, PT, PT_BYTE);
 26274       start_display (&it, w, pt);
 26275       /* When lines are truncated, we could be called with point
 26276          outside of the windows edges, in which case move_it_*
 26277          functions either prematurely stop at window's edge or jump to
 26278          the next screen line, whereas we rely below on our ability to
 26279          reach point, in order to start from its X coordinate.  So we
 26280          need to disregard the window's horizontal extent in that case.  */
 26281       if (it.line_wrap == TRUNCATE)
 26282         it.last_visible_x = DISP_INFINITY;
 26283 
 26284       if (it.cmp_it.id < 0
 26285           && it.method == GET_FROM_STRING
 26286           && it.area == TEXT_AREA
 26287           && it.string_from_display_prop_p
 26288           && (it.sp > 0 && it.stack[it.sp - 1].method == GET_FROM_BUFFER))
 26289         overshoot_expected = true;
 26290 
 26291       /* Find the X coordinate of point.  We start from the beginning
 26292          of this or previous line to make sure we are before point in
 26293          the logical order (since the move_it_* functions can only
 26294          move forward).  */
 26295     reseat:
 26296       reseat_at_previous_visible_line_start (&it);
 26297       it.current_x = it.hpos = it.current_y = it.vpos = 0;
 26298       if (IT_CHARPOS (it) != PT)
 26299         {
 26300           move_it_to (&it, overshoot_expected ? PT - 1 : PT,
 26301                       -1, -1, -1, MOVE_TO_POS);
 26302           /* If we missed point because the character there is
 26303              displayed out of a display vector that has more than one
 26304              glyph, retry expecting overshoot.  */
 26305           if (it.method == GET_FROM_DISPLAY_VECTOR
 26306               && it.current.dpvec_index > 0
 26307               && !overshoot_expected)
 26308             {
 26309               overshoot_expected = true;
 26310               goto reseat;
 26311             }
 26312           else if (IT_CHARPOS (it) != PT && !overshoot_expected)
 26313             move_it_in_display_line (&it, PT, -1, MOVE_TO_POS);
 26314         }
 26315       pt_x = it.current_x;
 26316       pt_vpos = it.vpos;
 26317       if (dir > 0 || overshoot_expected)
 26318         {
 26319           struct glyph_row *row = it.glyph_row;
 26320 
 26321           /* When point is at beginning of line, we don't have
 26322              information about the glyph there loaded into struct
 26323              it.  Calling get_next_display_element fixes that.  */
 26324           if (pt_x == 0)
 26325             get_next_display_element (&it);
 26326           at_eol_p = ITERATOR_AT_END_OF_LINE_P (&it);
 26327           it.glyph_row = NULL;
 26328           PRODUCE_GLYPHS (&it); /* compute it.pixel_width */
 26329           it.glyph_row = row;
 26330           /* PRODUCE_GLYPHS advances it.current_x, so we must restore
 26331              it, lest it will become out of sync with it's buffer
 26332              position.  */
 26333           it.current_x = pt_x;
 26334         }
 26335       else
 26336         at_eol_p = ITERATOR_AT_END_OF_LINE_P (&it);
 26337       pixel_width = it.pixel_width;
 26338       if (overshoot_expected && at_eol_p)
 26339         pixel_width = 0;
 26340       else if (pixel_width <= 0)
 26341         pixel_width = 1;
 26342 
 26343       /* If there's a display string (or something similar) at point,
 26344          we are actually at the glyph to the left of point, so we need
 26345          to correct the X coordinate.  */
 26346       if (overshoot_expected)
 26347         {
 26348           if (it.bidi_p)
 26349             pt_x += pixel_width * it.bidi_it.scan_dir;
 26350           else
 26351             pt_x += pixel_width;
 26352         }
 26353 
 26354       /* Compute target X coordinate, either to the left or to the
 26355          right of point.  On TTY frames, all characters have the same
 26356          pixel width of 1, so we can use that.  On GUI frames we don't
 26357          have an easy way of getting at the pixel width of the
 26358          character to the left of point, so we use a different method
 26359          of getting to that place.  */
 26360       if (dir > 0)
 26361         target_x = pt_x + pixel_width;
 26362       else
 26363         target_x = pt_x - (!FRAME_WINDOW_P (it.f)) * pixel_width;
 26364 
 26365       /* Target X coordinate could be one line above or below the line
 26366          of point, in which case we need to adjust the target X
 26367          coordinate.  Also, if moving to the left, we need to begin at
 26368          the left edge of the point's screen line.  */
 26369       if (dir < 0)
 26370         {
 26371           if (pt_x > 0)
 26372             {
 26373               start_display (&it, w, pt);
 26374               if (it.line_wrap == TRUNCATE)
 26375                 it.last_visible_x = DISP_INFINITY;
 26376               reseat_at_previous_visible_line_start (&it);
 26377               it.current_x = it.current_y = it.hpos = 0;
 26378               if (pt_vpos != 0)
 26379                 move_it_by_lines (&it, pt_vpos);
 26380             }
 26381           else
 26382             {
 26383               move_it_by_lines (&it, -1);
 26384               target_x = it.last_visible_x - !FRAME_WINDOW_P (it.f);
 26385               target_is_eol_p = true;
 26386               /* Under word-wrap, we don't know the x coordinate of
 26387                  the last character displayed on the previous line,
 26388                  which immediately precedes the wrap point.  To find
 26389                  out its x coordinate, we try moving to the right
 26390                  margin of the window, which will stop at the wrap
 26391                  point, and then reset target_x to point at the
 26392                  character that precedes the wrap point.  This is not
 26393                  needed on GUI frames, because (see below) there we
 26394                  move from the left margin one grapheme cluster at a
 26395                  time, and stop when we hit the wrap point.  */
 26396               if (!FRAME_WINDOW_P (it.f) && it.line_wrap == WORD_WRAP)
 26397                 {
 26398                   void *it_data = NULL;
 26399                   struct it it2;
 26400 
 26401                   SAVE_IT (it2, it, it_data);
 26402                   move_it_in_display_line_to (&it, ZV, target_x,
 26403                                               MOVE_TO_POS | MOVE_TO_X);
 26404                   /* If we arrived at target_x, that _is_ the last
 26405                      character on the previous line.  */
 26406                   if (it.current_x != target_x)
 26407                     target_x = it.current_x - 1;
 26408                   RESTORE_IT (&it, &it2, it_data);
 26409                 }
 26410             }
 26411         }
 26412       else
 26413         {
 26414           if (at_eol_p
 26415               || (target_x >= it.last_visible_x
 26416                   && it.line_wrap != TRUNCATE))
 26417             {
 26418               if (pt_x > 0)
 26419                 move_it_by_lines (&it, 0);
 26420               move_it_by_lines (&it, 1);
 26421               target_x = 0;
 26422             }
 26423         }
 26424 
 26425       /* Move to the target X coordinate.  */
 26426       /* On GUI frames, as we don't know the X coordinate of the
 26427          character to the left of point, moving point to the left
 26428          requires walking, one grapheme cluster at a time, until we
 26429          find ourself at a place immediately to the left of the
 26430          character at point.  */
 26431       if (FRAME_WINDOW_P (it.f) && dir < 0)
 26432         {
 26433           struct text_pos new_pos;
 26434           enum move_it_result rc = MOVE_X_REACHED;
 26435 
 26436           if (it.current_x == 0)
 26437             get_next_display_element (&it);
 26438           if (it.what == IT_COMPOSITION)
 26439             {
 26440               new_pos.charpos = it.cmp_it.charpos;
 26441               new_pos.bytepos = -1;
 26442             }
 26443           else
 26444             new_pos = it.current.pos;
 26445 
 26446           while (it.current_x + it.pixel_width <= target_x
 26447                  && (rc == MOVE_X_REACHED
 26448                      /* Under word-wrap, move_it_in_display_line_to
 26449                         stops at correct coordinates, but sometimes
 26450                         returns MOVE_POS_MATCH_OR_ZV.  */
 26451                      || (it.line_wrap == WORD_WRAP
 26452                          && rc == MOVE_POS_MATCH_OR_ZV)))
 26453             {
 26454               int new_x = it.current_x + it.pixel_width;
 26455 
 26456               /* For composed characters, we want the position of the
 26457                  first character in the grapheme cluster (usually, the
 26458                  composition's base character), whereas it.current
 26459                  might give us the position of the _last_ one, e.g. if
 26460                  the composition is rendered in reverse due to bidi
 26461                  reordering.  */
 26462               if (it.what == IT_COMPOSITION)
 26463                 {
 26464                   new_pos.charpos = it.cmp_it.charpos;
 26465                   new_pos.bytepos = -1;
 26466                 }
 26467               else
 26468                 new_pos = it.current.pos;
 26469               if (new_x == it.current_x)
 26470                 new_x++;
 26471               rc = move_it_in_display_line_to (&it, ZV, new_x,
 26472                                                MOVE_TO_POS | MOVE_TO_X);
 26473               if (ITERATOR_AT_END_OF_LINE_P (&it) && !target_is_eol_p)
 26474                 break;
 26475             }
 26476           /* The previous position we saw in the loop is the one we
 26477              want.  */
 26478           if (new_pos.bytepos == -1)
 26479             new_pos.bytepos = CHAR_TO_BYTE (new_pos.charpos);
 26480           it.current.pos = new_pos;
 26481         }
 26482       else if (it.current_x != target_x)
 26483         move_it_in_display_line_to (&it, ZV, target_x, MOVE_TO_POS | MOVE_TO_X);
 26484 
 26485       /* If we ended up in a display string that covers point, move to
 26486          buffer position to the right in the visual order.  */
 26487       if (dir > 0)
 26488         {
 26489           while (IT_CHARPOS (it) == PT)
 26490             {
 26491               set_iterator_to_next (&it, false);
 26492               if (!get_next_display_element (&it))
 26493                 break;
 26494             }
 26495         }
 26496 
 26497       /* Move point to that position.  */
 26498       SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
 26499       bidi_unshelve_cache (itdata, false);
 26500     }
 26501 
 26502   return make_fixnum (PT);
 26503 
 26504 #undef ROW_GLYPH_NEWLINE_P
 26505 }
 26506 
 26507 DEFUN ("bidi-resolved-levels", Fbidi_resolved_levels,
 26508        Sbidi_resolved_levels, 0, 1, 0,
 26509        doc: /* Return the resolved bidirectional levels of characters at VPOS.
 26510 
 26511 The resolved levels are produced by the Emacs bidi reordering engine
 26512 that implements the UBA, the Unicode Bidirectional Algorithm.  Please
 26513 read the Unicode Standard Annex 9 (UAX#9) for background information
 26514 about these levels.
 26515 
 26516 VPOS is the zero-based number of the current window's screen line
 26517 for which to produce the resolved levels.  If VPOS is nil or omitted,
 26518 it defaults to the screen line of point.  If the window displays a
 26519 header line, VPOS of zero will report on the header line, and first
 26520 line of text in the window will have VPOS of 1.
 26521 
 26522 Value is an array of resolved levels, indexed by glyph number.
 26523 Glyphs are numbered from zero starting from the beginning of the
 26524 screen line, i.e. the left edge of the window for left-to-right lines
 26525 and from the right edge for right-to-left lines.  The resolved levels
 26526 are produced only for the window's text area; text in display margins
 26527 is not included.
 26528 
 26529 If the selected window's display is not up-to-date, or if the specified
 26530 screen line does not display text, this function returns nil.  It is
 26531 highly recommended to bind this function to some simple key, like F8,
 26532 in order to avoid these problems.
 26533 
 26534 This function exists mainly for testing the correctness of the
 26535 Emacs UBA implementation, in particular with the test suite.  */)
 26536   (Lisp_Object vpos)
 26537 {
 26538   struct window *w = XWINDOW (selected_window);
 26539   struct buffer *b = XBUFFER (w->contents);
 26540   int nrow;
 26541   struct glyph_row *row;
 26542 
 26543   if (NILP (vpos))
 26544     {
 26545       int d1, d2, d3, d4, d5;
 26546 
 26547       pos_visible_p (w, PT, &d1, &d2, &d3, &d4, &d5, &nrow);
 26548     }
 26549   else
 26550     {
 26551       CHECK_FIXNUM (vpos);
 26552       nrow = XFIXNUM (vpos);
 26553     }
 26554 
 26555   /* We require up-to-date glyph matrix for this window.  */
 26556   if (w->window_end_valid
 26557       && !windows_or_buffers_changed
 26558       && b
 26559       && !b->clip_changed
 26560       && !b->prevent_redisplay_optimizations_p
 26561       && !window_outdated (w)
 26562       && nrow >= 0
 26563       && nrow < w->current_matrix->nrows
 26564       && (row = MATRIX_ROW (w->current_matrix, nrow))->enabled_p
 26565       && MATRIX_ROW_DISPLAYS_TEXT_P (row))
 26566     {
 26567       struct glyph *g, *e, *g1;
 26568       int nglyphs, i;
 26569       Lisp_Object levels;
 26570 
 26571       if (!row->reversed_p)     /* Left-to-right glyph row.  */
 26572         {
 26573           g = g1 = row->glyphs[TEXT_AREA];
 26574           e = g + row->used[TEXT_AREA];
 26575 
 26576           /* Skip over glyphs at the start of the row that was
 26577              generated by redisplay for its own needs.  */
 26578           while (g < e
 26579                  && NILP (g->object)
 26580                  && g->charpos < 0)
 26581             g++;
 26582           g1 = g;
 26583 
 26584           /* Count the "interesting" glyphs in this row.  */
 26585           for (nglyphs = 0; g < e && !NILP (g->object); g++)
 26586             nglyphs++;
 26587 
 26588           /* Create and fill the array.  */
 26589           levels = make_uninit_vector (nglyphs);
 26590           for (i = 0; g1 < g; i++, g1++)
 26591             ASET (levels, i, make_fixnum (g1->resolved_level));
 26592         }
 26593       else                      /* Right-to-left glyph row.  */
 26594         {
 26595           g = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
 26596           e = row->glyphs[TEXT_AREA] - 1;
 26597           while (g > e
 26598                  && NILP (g->object)
 26599                  && g->charpos < 0)
 26600             g--;
 26601           g1 = g;
 26602           for (nglyphs = 0; g > e && !NILP (g->object); g--)
 26603             nglyphs++;
 26604           levels = make_uninit_vector (nglyphs);
 26605           for (i = 0; g1 > g; i++, g1--)
 26606             ASET (levels, i, make_fixnum (g1->resolved_level));
 26607         }
 26608       return levels;
 26609     }
 26610   else
 26611     return Qnil;
 26612 }
 26613 
 26614 
 26615 
 26616 /***********************************************************************
 26617                                Menu Bar
 26618  ***********************************************************************/
 26619 
 26620 /* Redisplay the menu bar in the frame for window W.
 26621 
 26622    The menu bar of X frames that don't have X toolkit support is
 26623    displayed in a special window W->frame->menu_bar_window.
 26624 
 26625    The menu bar of terminal frames is treated specially as far as
 26626    glyph matrices are concerned.  Menu bar lines are not part of
 26627    windows, so the update is done directly on the frame matrix rows
 26628    for the menu bar.  */
 26629 
 26630 static void
 26631 display_menu_bar (struct window *w)
 26632 {
 26633   struct frame *f = XFRAME (WINDOW_FRAME (w));
 26634   struct it it;
 26635   Lisp_Object items;
 26636   int i;
 26637 
 26638   /* Don't do all this for graphical frames.  */
 26639 #ifdef HAVE_NTGUI
 26640   if (FRAME_W32_P (f))
 26641     return;
 26642 #endif
 26643 #if defined (HAVE_PGTK)
 26644   if (FRAME_PGTK_P (f))
 26645     return;
 26646 #endif
 26647 
 26648 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
 26649   if (FRAME_X_P (f))
 26650     return;
 26651 #endif
 26652 
 26653 #ifdef HAVE_NS
 26654   if (FRAME_NS_P (f))
 26655     return;
 26656 #endif /* HAVE_NS */
 26657 
 26658 #ifdef HAVE_HAIKU
 26659   if (FRAME_HAIKU_P (f))
 26660     return;
 26661 #endif /* HAVE_HAIKU */
 26662 
 26663 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
 26664   eassert (!FRAME_WINDOW_P (f));
 26665   init_iterator (&it, w, -1, -1, f->desired_matrix->rows, MENU_FACE_ID);
 26666   it.first_visible_x = 0;
 26667   it.last_visible_x = FRAME_PIXEL_WIDTH (f);
 26668 #elif defined (HAVE_X_WINDOWS) || defined (HAVE_ANDROID)
 26669   struct window *menu_window = NULL;
 26670   struct face *face = FACE_FROM_ID (f, MENU_FACE_ID);
 26671 
 26672   if (FRAME_WINDOW_P (f))
 26673     {
 26674       /* Menu bar lines are displayed in the desired matrix of the
 26675          dummy window menu_bar_window.  */
 26676       menu_window = XWINDOW (f->menu_bar_window);
 26677       init_iterator (&it, menu_window, -1, -1,
 26678                      menu_window->desired_matrix->rows,
 26679                      MENU_FACE_ID);
 26680     }
 26681   else
 26682 #endif /* not USE_X_TOOLKIT and not USE_GTK */
 26683     {
 26684       /* This is a TTY frame, i.e. character hpos/vpos are used as
 26685          pixel x/y.  */
 26686       init_iterator (&it, w, -1, -1, f->desired_matrix->rows,
 26687                      MENU_FACE_ID);
 26688       it.first_visible_x = 0;
 26689       it.last_visible_x = FRAME_COLS (f);
 26690     }
 26691 
 26692   /* FIXME: This should be controlled by a user option.  See the
 26693      comments in redisplay_tool_bar and display_mode_line about
 26694      this.  */
 26695   it.paragraph_embedding = L2R;
 26696 
 26697   /* Clear all rows of the menu bar.  */
 26698   for (i = 0; i < FRAME_MENU_BAR_LINES (f); ++i)
 26699     {
 26700       struct glyph_row *row = it.glyph_row + i;
 26701       clear_glyph_row (row);
 26702       row->enabled_p = true;
 26703       row->full_width_p = true;
 26704       row->reversed_p = false;
 26705     }
 26706 
 26707   /* Display all items of the menu bar.  */
 26708   items = FRAME_MENU_BAR_ITEMS (it.f);
 26709   for (i = 0; i < ASIZE (items); i += 4)
 26710     {
 26711       Lisp_Object string;
 26712 
 26713       /* Stop at nil string.  */
 26714       string = AREF (items, i + 1);
 26715       if (NILP (string))
 26716         break;
 26717 
 26718       /* Remember where item was displayed.  */
 26719       ASET (items, i + 3, make_fixnum (it.hpos));
 26720 
 26721       /* Display the item, pad with one space.  */
 26722       if (it.current_x < it.last_visible_x)
 26723         display_string (NULL, string, Qnil, 0, 0, &it,
 26724                         SCHARS (string) + 1, 0, 0, STRING_MULTIBYTE (string));
 26725     }
 26726 
 26727   /* Fill out the line with spaces.  */
 26728   if (it.current_x < it.last_visible_x)
 26729     display_string ("", Qnil, Qnil, 0, 0, &it, -1, 0, 0, -1);
 26730 
 26731   /* Compute the total height of the lines.  */
 26732   compute_line_metrics (&it);
 26733   it.glyph_row->full_width_p = true;
 26734   it.glyph_row->continued_p = false;
 26735   it.glyph_row->truncated_on_left_p = false;
 26736   it.glyph_row->truncated_on_right_p = false;
 26737 
 26738   /* This will break the moment someone tries to add another window
 26739      system that uses the no toolkit menu bar.  Oh well.  At least
 26740      there will be an error, meaning he will correct the ifdef inside
 26741      which `face' is defined.  */
 26742 #if defined HAVE_WINDOW_SYSTEM && !defined HAVE_EXT_MENU_BAR
 26743   /* Make a 3D menu bar have a shadow at its right end.  */
 26744   extend_face_to_end_of_line (&it);
 26745   if (face->box != FACE_NO_BOX)
 26746     {
 26747       struct glyph *last = (it.glyph_row->glyphs[TEXT_AREA]
 26748                             + it.glyph_row->used[TEXT_AREA] - 1);
 26749       int box_thickness = face->box_vertical_line_width;
 26750       last->right_box_line_p = true;
 26751       /* Add back the space for the right box line we subtracted in
 26752          init_iterator, since the right_box_line_p flag will make the
 26753          glyph wider.  We actually add only as much space as is
 26754          available for the last glyph of the menu bar and whatever
 26755          space is left beyond it, since that glyph could be only
 26756          partially visible.  */
 26757       if (box_thickness > 0)
 26758         last->pixel_width += max (0, (box_thickness
 26759                                       - (it.current_x - it.last_visible_x)));
 26760     }
 26761 
 26762   /* With the non-toolkit version, modify the menu bar window height
 26763      accordingly.  */
 26764   if (FRAME_WINDOW_P (it.f) && menu_window)
 26765     {
 26766       struct glyph_row *row;
 26767       int delta_height;
 26768 
 26769       row = it.glyph_row;
 26770       delta_height
 26771         = ((row->y + row->height)
 26772            - WINDOW_BOX_HEIGHT_NO_MODE_LINE (menu_window));
 26773 
 26774       if (delta_height != 0)
 26775         {
 26776           FRAME_MENU_BAR_HEIGHT (it.f) += delta_height;
 26777           adjust_frame_size (it.f, -1, -1, 3, false, Qmenu_bar_lines);
 26778         }
 26779     }
 26780 #endif
 26781 }
 26782 
 26783 /* This code is never used on Android where there are only GUI and
 26784    initial frames.  */
 26785 
 26786 #ifndef HAVE_ANDROID
 26787 
 26788 /* Deep copy of a glyph row, including the glyphs.  */
 26789 static void
 26790 deep_copy_glyph_row (struct glyph_row *to, struct glyph_row *from)
 26791 {
 26792   struct glyph *pointers[1 + LAST_AREA];
 26793   int to_used = to->used[TEXT_AREA];
 26794 
 26795   /* Save glyph pointers of TO.  */
 26796   memcpy (pointers, to->glyphs, sizeof to->glyphs);
 26797 
 26798   /* Do a structure assignment.  */
 26799   *to = *from;
 26800 
 26801   /* Restore original glyph pointers of TO.  */
 26802   memcpy (to->glyphs, pointers, sizeof to->glyphs);
 26803 
 26804   /* Copy the glyphs.  */
 26805   memcpy (to->glyphs[TEXT_AREA], from->glyphs[TEXT_AREA],
 26806           min (from->used[TEXT_AREA], to_used) * sizeof (struct glyph));
 26807 
 26808   /* If we filled only part of the TO row, fill the rest with
 26809      space_glyph (which will display as empty space).  */
 26810   if (to_used > from->used[TEXT_AREA])
 26811     fill_up_frame_row_with_spaces (to, to_used);
 26812 }
 26813 
 26814 /* Display one menu item on a TTY, by overwriting the glyphs in the
 26815    frame F's desired glyph matrix with glyphs produced from the menu
 26816    item text.  Called from term.c to display TTY drop-down menus one
 26817    item at a time.
 26818 
 26819    ITEM_TEXT is the menu item text as a C string.
 26820 
 26821    FACE_ID is the face ID to be used for this menu item.  FACE_ID
 26822    could specify one of 3 faces: a face for an enabled item, a face
 26823    for a disabled item, or a face for a selected item.
 26824 
 26825    X and Y are coordinates of the first glyph in the frame's desired
 26826    matrix to be overwritten by the menu item.  Since this is a TTY, Y
 26827    is the zero-based number of the glyph row and X is the zero-based
 26828    glyph number in the row, starting from left, where to start
 26829    displaying the item.
 26830 
 26831    SUBMENU means this menu item drops down a submenu, which
 26832    should be indicated by displaying a proper visual cue after the
 26833    item text.  */
 26834 
 26835 void
 26836 display_tty_menu_item (const char *item_text, int width, int face_id,
 26837                        int x, int y, bool submenu)
 26838 {
 26839   struct it it;
 26840   struct frame *f = SELECTED_FRAME ();
 26841   struct window *w = XWINDOW (f->selected_window);
 26842   struct glyph_row *row;
 26843   size_t item_len = strlen (item_text);
 26844 
 26845   eassert (FRAME_TERMCAP_P (f));
 26846 
 26847   /* Don't write beyond the matrix's last row.  This can happen for
 26848      TTY screens that are not high enough to show the entire menu.
 26849      (This is actually a bit of defensive programming, as
 26850      tty_menu_display already limits the number of menu items to one
 26851      less than the number of screen lines.)  */
 26852   if (y >= f->desired_matrix->nrows)
 26853     return;
 26854 
 26855   init_iterator (&it, w, -1, -1, f->desired_matrix->rows + y, MENU_FACE_ID);
 26856   it.first_visible_x = 0;
 26857   it.last_visible_x = FRAME_COLS (f) - 1;
 26858   row = it.glyph_row;
 26859   /* Start with the row contents from the current matrix.  */
 26860   deep_copy_glyph_row (row, f->current_matrix->rows + y);
 26861   bool saved_width = row->full_width_p;
 26862   row->full_width_p = true;
 26863   bool saved_reversed = row->reversed_p;
 26864   row->reversed_p = false;
 26865   row->enabled_p = true;
 26866 
 26867   /* Arrange for the menu item glyphs to start at (X,Y) and have the
 26868      desired face.  */
 26869   eassert (x < f->desired_matrix->matrix_w);
 26870   it.current_x = it.hpos = x;
 26871   it.current_y = it.vpos = y;
 26872   int saved_used = row->used[TEXT_AREA];
 26873   bool saved_truncated = row->truncated_on_right_p;
 26874   row->used[TEXT_AREA] = x;
 26875   it.face_id = face_id;
 26876   it.line_wrap = TRUNCATE;
 26877 
 26878   /* FIXME: This should be controlled by a user option.  See the
 26879      comments in redisplay_tool_bar and display_mode_line about this.
 26880      Also, if paragraph_embedding could ever be R2L, changes will be
 26881      needed to avoid shifting to the right the row characters in
 26882      term.c:append_glyph.  */
 26883   it.paragraph_embedding = L2R;
 26884 
 26885   /* Pad with a space on the left.  */
 26886   display_string (" ", Qnil, Qnil, 0, 0, &it, 1, 0, FRAME_COLS (f) - 1, -1);
 26887   width--;
 26888   /* Display the menu item, pad with spaces to WIDTH.  */
 26889   if (submenu)
 26890     {
 26891       display_string (item_text, Qnil, Qnil, 0, 0, &it,
 26892                       item_len, 0, FRAME_COLS (f) - 1, -1);
 26893       width -= item_len;
 26894       /* Indicate with " >" that there's a submenu.  */
 26895       display_string (" >", Qnil, Qnil, 0, 0, &it, width, 0,
 26896                       FRAME_COLS (f) - 1, -1);
 26897     }
 26898   else
 26899     display_string (item_text, Qnil, Qnil, 0, 0, &it,
 26900                     width, 0, FRAME_COLS (f) - 1, -1);
 26901 
 26902   row->used[TEXT_AREA] = max (saved_used, row->used[TEXT_AREA]);
 26903   row->truncated_on_right_p = saved_truncated;
 26904   row->hash = row_hash (row);
 26905   row->full_width_p = saved_width;
 26906   row->reversed_p = saved_reversed;
 26907 }
 26908 
 26909 #endif
 26910 
 26911 
 26912 /***********************************************************************
 26913                               Mode Line
 26914  ***********************************************************************/
 26915 
 26916 /* Redisplay mode lines in the window tree whose root is WINDOW.
 26917    If FORCE, redisplay mode lines unconditionally.
 26918    Otherwise, redisplay only mode lines that are garbaged.  Value is
 26919    the number of windows whose mode lines were redisplayed.  */
 26920 
 26921 static int
 26922 redisplay_mode_lines (Lisp_Object window, bool force)
 26923 {
 26924   int nwindows = 0;
 26925 
 26926   while (!NILP (window))
 26927     {
 26928       struct window *w = XWINDOW (window);
 26929 
 26930       if (WINDOWP (w->contents))
 26931         nwindows += redisplay_mode_lines (w->contents, force);
 26932       else if (force
 26933                || FRAME_GARBAGED_P (XFRAME (w->frame))
 26934                || !MATRIX_MODE_LINE_ROW (w->current_matrix)->enabled_p)
 26935         {
 26936           struct text_pos lpoint;
 26937           struct buffer *old = current_buffer;
 26938 
 26939           /* Set the window's buffer for the mode line display.  */
 26940           SET_TEXT_POS (lpoint, PT, PT_BYTE);
 26941           set_buffer_internal_1 (XBUFFER (w->contents));
 26942 
 26943           /* Point refers normally to the selected window.  For any
 26944              other window, set up appropriate value.  */
 26945           if (!EQ (window, selected_window))
 26946             {
 26947               struct text_pos pt;
 26948 
 26949               CLIP_TEXT_POS_FROM_MARKER (pt, w->pointm);
 26950               TEMP_SET_PT_BOTH (CHARPOS (pt), BYTEPOS (pt));
 26951             }
 26952 
 26953           /* Display mode lines.  */
 26954           clear_glyph_matrix (w->desired_matrix);
 26955           if (display_mode_lines (w))
 26956             ++nwindows;
 26957 
 26958           /* Restore old settings.  */
 26959           set_buffer_internal_1 (old);
 26960           TEMP_SET_PT_BOTH (CHARPOS (lpoint), BYTEPOS (lpoint));
 26961         }
 26962 
 26963       window = w->next;
 26964     }
 26965 
 26966   return nwindows;
 26967 }
 26968 
 26969 
 26970 /* Display the mode line, the header line, and the tab-line of window
 26971    W.  Value is the sum number of mode lines, header lines, and tab
 26972    lines actually displayed.  */
 26973 
 26974 static int
 26975 display_mode_lines (struct window *w)
 26976 {
 26977   Lisp_Object old_selected_window = selected_window;
 26978   Lisp_Object new_frame = w->frame;
 26979   specpdl_ref count = SPECPDL_INDEX ();
 26980   int n = 0;
 26981 
 26982   record_unwind_protect (restore_selected_window, selected_window);
 26983   record_unwind_protect
 26984     (restore_frame_selected_window, XFRAME (new_frame)->selected_window);
 26985 
 26986   if (window_wants_mode_line (w))
 26987     {
 26988       Lisp_Object window;
 26989       Lisp_Object default_help
 26990         = buffer_local_value (Qmode_line_default_help_echo, w->contents);
 26991 
 26992       /* Set up mode line help echo.  Do this before selecting w so it
 26993          can reasonably tell whether a mouse click will select w.  */
 26994       XSETWINDOW (window, w);
 26995       if (FUNCTIONP (default_help))
 26996         wset_mode_line_help_echo (w, safe_call1 (default_help, window));
 26997       else if (STRINGP (default_help))
 26998         wset_mode_line_help_echo (w, default_help);
 26999       else
 27000         wset_mode_line_help_echo (w, Qnil);
 27001     }
 27002 
 27003   selected_frame = new_frame;
 27004   /* FIXME: If we were to allow the mode-line's computation changing the buffer
 27005      or window's point, then we'd need select_window_1 here as well.  */
 27006   XSETWINDOW (selected_window, w);
 27007   XFRAME (new_frame)->selected_window = selected_window;
 27008 
 27009   /* These will be set while the mode line specs are processed.  */
 27010   line_number_displayed = false;
 27011   w->column_number_displayed = -1;
 27012 
 27013   if (window_wants_mode_line (w))
 27014     {
 27015       Lisp_Object window_mode_line_format
 27016         = window_parameter (w, Qmode_line_format);
 27017       struct window *sel_w = XWINDOW (old_selected_window);
 27018 
 27019       /* Select mode line face based on the real selected window.  */
 27020       display_mode_line (w,
 27021                          CURRENT_MODE_LINE_ACTIVE_FACE_ID_3 (sel_w, sel_w, w),
 27022                          NILP (window_mode_line_format)
 27023                          ? BVAR (current_buffer, mode_line_format)
 27024                          : window_mode_line_format);
 27025       ++n;
 27026     }
 27027 
 27028   if (window_wants_tab_line (w))
 27029     {
 27030       Lisp_Object window_tab_line_format
 27031         = window_parameter (w, Qtab_line_format);
 27032 
 27033       display_mode_line (w, TAB_LINE_FACE_ID,
 27034                          NILP (window_tab_line_format)
 27035                          ? BVAR (current_buffer, tab_line_format)
 27036                          : window_tab_line_format);
 27037       ++n;
 27038     }
 27039 
 27040   if (window_wants_header_line (w))
 27041     {
 27042       Lisp_Object window_header_line_format
 27043         = window_parameter (w, Qheader_line_format);
 27044 
 27045       display_mode_line (w, HEADER_LINE_FACE_ID,
 27046                          NILP (window_header_line_format)
 27047                          ? BVAR (current_buffer, header_line_format)
 27048                          : window_header_line_format);
 27049       ++n;
 27050     }
 27051 
 27052   unbind_to (count, Qnil);
 27053 
 27054   if (n > 0)
 27055     w->must_be_updated_p = true;
 27056   return n;
 27057 }
 27058 
 27059 
 27060 /* Display mode or header/tab line of window W.  FACE_ID specifies
 27061    which line to display; it is either MODE_LINE_ACTIVE_FACE_ID,
 27062    HEADER_LINE_FACE_ID or TAB_LINE_FACE_ID.  FORMAT is the
 27063    mode/header/tab line format to display.  Value is the pixel height
 27064    of the mode/header/tab line displayed.  */
 27065 
 27066 static int
 27067 display_mode_line (struct window *w, enum face_id face_id, Lisp_Object format)
 27068 {
 27069   struct it it;
 27070   struct face *face;
 27071   specpdl_ref count = SPECPDL_INDEX ();
 27072 
 27073   init_iterator (&it, w, -1, -1, NULL, face_id);
 27074   /* Don't extend on a previously drawn mode-line.
 27075      This may happen if called from pos_visible_p.  */
 27076   it.glyph_row->enabled_p = false;
 27077   prepare_desired_row (w, it.glyph_row, true);
 27078 
 27079   it.glyph_row->mode_line_p = true;
 27080   if (face_id == TAB_LINE_FACE_ID)
 27081     {
 27082       it.glyph_row->tab_line_p = true;
 27083       w->desired_matrix->tab_line_p = true;
 27084     }
 27085   else if (face_id == HEADER_LINE_FACE_ID)
 27086     w->desired_matrix->header_line_p = true;
 27087 
 27088   /* FIXME: This should be controlled by a user option.  But
 27089      supporting such an option is not trivial, since the mode line is
 27090      made up of many separate strings.  */
 27091   it.paragraph_embedding = L2R;
 27092 
 27093   record_unwind_protect (unwind_format_mode_line,
 27094                          format_mode_line_unwind_data (NULL, NULL,
 27095                                                        Qnil, false));
 27096 
 27097   /* Temporarily make frame's keyboard the current kboard so that
 27098      kboard-local variables in the mode_line_format will get the right
 27099      values.  */
 27100   push_kboard (FRAME_KBOARD (it.f));
 27101   record_unwind_save_match_data ();
 27102 
 27103   if (NILP (Vmode_line_compact)
 27104       || face_id == HEADER_LINE_FACE_ID || face_id == TAB_LINE_FACE_ID)
 27105     {
 27106       mode_line_target = MODE_LINE_DISPLAY;
 27107       display_mode_element (&it, 0, 0, 0, format, Qnil, false);
 27108     }
 27109   else
 27110     {
 27111       Lisp_Object mode_string = Fformat_mode_line (format, Qnil, Qnil, Qnil);
 27112       if (EQ (Vmode_line_compact, Qlong)
 27113           && WINDOW_TOTAL_COLS (w) >= SCHARS (mode_string))
 27114         {
 27115           /* The window is wide enough; just display the mode line we
 27116              just computed. */
 27117           display_string (NULL, mode_string, Qnil,
 27118                           0, 0, &it, 0, 0, 0,
 27119                           STRING_MULTIBYTE (mode_string));
 27120         }
 27121       else
 27122         {
 27123           /* Compress the mode line. */
 27124           ptrdiff_t i = 0, i_byte = 0, start = 0;
 27125           int prev = 0;
 27126 
 27127           while (i < SCHARS (mode_string))
 27128             {
 27129               int c = fetch_string_char_advance (mode_string, &i, &i_byte);
 27130               if (c == ' ' && prev == ' ')
 27131                 {
 27132                   display_string (NULL,
 27133                                   Fsubstring (mode_string, make_fixnum (start),
 27134                                               make_fixnum (i - 1)),
 27135                                   Qnil, 0, 0, &it, 0, 0, 0,
 27136                                   STRING_MULTIBYTE (mode_string));
 27137                   /* Skip past the rest of the space characters. */
 27138                   while (c == ' ' && i < SCHARS (mode_string))
 27139                       c = fetch_string_char_advance (mode_string, &i, &i_byte);
 27140                   start = i - 1;
 27141                 }
 27142               prev = c;
 27143             }
 27144 
 27145           /* Display the final bit. */
 27146           if (start < i)
 27147             display_string (NULL,
 27148                             Fsubstring (mode_string, make_fixnum (start),
 27149                                         make_fixnum (i)),
 27150                             Qnil, 0, 0, &it, 0, 0, 0,
 27151                             STRING_MULTIBYTE (mode_string));
 27152         }
 27153     }
 27154   pop_kboard ();
 27155 
 27156   unbind_to (count, Qnil);
 27157 
 27158   /* Fill up with spaces.  */
 27159   display_string (" ", Qnil, Qnil, 0, 0, &it, 10000, -1, -1, 0);
 27160 
 27161   compute_line_metrics (&it);
 27162   it.glyph_row->full_width_p = true;
 27163   it.glyph_row->continued_p = false;
 27164   it.glyph_row->truncated_on_left_p = false;
 27165   it.glyph_row->truncated_on_right_p = false;
 27166 
 27167   /* Make a 3D mode-line have a shadow at its right end.  */
 27168   face = FACE_FROM_ID (it.f, face_id);
 27169   extend_face_to_end_of_line (&it);
 27170   if (face->box != FACE_NO_BOX)
 27171     {
 27172       struct glyph *last = (it.glyph_row->glyphs[TEXT_AREA]
 27173                             + it.glyph_row->used[TEXT_AREA] - 1);
 27174       int box_thickness = face->box_vertical_line_width;
 27175       last->right_box_line_p = true;
 27176       /* Add back the space for the right box line we subtracted in
 27177          init_iterator, since the right_box_line_p flag will make the
 27178          glyph wider.  We actually add only as much space as is
 27179          available for the last glyph of the modeline and whatever
 27180          space is left beyond it, since that glyph could be only
 27181          partially visible */
 27182       if (box_thickness > 0)
 27183         last->pixel_width += max (0, (box_thickness
 27184                                       - (it.current_x - it.last_visible_x)));
 27185     }
 27186 
 27187   return it.glyph_row->height;
 27188 }
 27189 
 27190 /* Move element ELT in LIST to the front of LIST.
 27191    Return the updated list.  */
 27192 
 27193 static Lisp_Object
 27194 move_elt_to_front (Lisp_Object elt, Lisp_Object list)
 27195 {
 27196   register Lisp_Object tail, prev;
 27197   register Lisp_Object tem;
 27198 
 27199   tail = list;
 27200   prev = Qnil;
 27201   while (CONSP (tail))
 27202     {
 27203       tem = XCAR (tail);
 27204 
 27205       if (EQ (elt, tem))
 27206         {
 27207           /* Splice out the link TAIL.  */
 27208           if (NILP (prev))
 27209             list = XCDR (tail);
 27210           else
 27211             Fsetcdr (prev, XCDR (tail));
 27212 
 27213           /* Now make it the first.  */
 27214           Fsetcdr (tail, list);
 27215           return tail;
 27216         }
 27217       else
 27218         prev = tail;
 27219       tail = XCDR (tail);
 27220       maybe_quit ();
 27221     }
 27222 
 27223   /* Not found--return unchanged LIST.  */
 27224   return list;
 27225 }
 27226 
 27227 /* Subroutine to call Fset_text_properties through
 27228    internal_condition_case_n.  ARGS are the arguments of
 27229    Fset_text_properties, in order.  */
 27230 
 27231 static Lisp_Object
 27232 safe_set_text_properties (ptrdiff_t nargs, Lisp_Object *args)
 27233 {
 27234   eassert (nargs == 4);
 27235   return Fset_text_properties (args[0], args[1], args[2], args[3]);
 27236 }
 27237 
 27238 /* Contribute ELT to the mode line for window IT->w.  How it
 27239    translates into text depends on its data type.
 27240 
 27241    IT describes the display environment in which we display, as usual.
 27242 
 27243    DEPTH is the depth in recursion.  It is used to prevent
 27244    infinite recursion here.
 27245 
 27246    FIELD_WIDTH is the number of characters the display of ELT should
 27247    occupy in the mode line, and PRECISION is the maximum number of
 27248    characters to display from ELT's representation.  See
 27249    display_string for details.
 27250 
 27251    Returns the hpos of the end of the text generated by ELT.
 27252 
 27253    PROPS is a property list to add to any string we encounter.
 27254 
 27255    If RISKY, remove (disregard) any properties in any string
 27256    we encounter, and ignore :eval and :propertize.
 27257 
 27258    The global variable `mode_line_target' determines whether the
 27259    output is passed to `store_mode_line_noprop',
 27260    `store_mode_line_string', or `display_string'.  */
 27261 
 27262 static int
 27263 display_mode_element (struct it *it, int depth, int field_width, int precision,
 27264                       Lisp_Object elt, Lisp_Object props, bool risky)
 27265 {
 27266   int n = 0, field, prec;
 27267   bool literal = false;
 27268 
 27269  tail_recurse:
 27270   if (depth > 100)
 27271     elt = build_string ("*too-deep*");
 27272 
 27273   depth++;
 27274 
 27275   switch (XTYPE (elt))
 27276     {
 27277     case Lisp_String:
 27278       {
 27279         /* A string: output it and check for %-constructs within it.  */
 27280         unsigned char c;
 27281         ptrdiff_t offset = 0;
 27282 
 27283         if (SCHARS (elt) > 0
 27284             && (!NILP (props) || risky))
 27285           {
 27286             Lisp_Object oprops, aelt;
 27287             oprops = Ftext_properties_at (make_fixnum (0), elt);
 27288 
 27289             /* If the starting string's properties are not what
 27290                we want, translate the string.  Also, if the string
 27291                is risky, do that anyway.  */
 27292 
 27293             if (NILP (Fequal (props, oprops)) || risky)
 27294               {
 27295                 /* If the starting string has properties,
 27296                    merge the specified ones onto the existing ones.  */
 27297                 if (! NILP (oprops) && !risky)
 27298                   {
 27299                     Lisp_Object tem;
 27300 
 27301                     oprops = Fcopy_sequence (oprops);
 27302                     tem = props;
 27303                     while (CONSP (tem))
 27304                       {
 27305                         oprops = plist_put (oprops, XCAR (tem),
 27306                                             XCAR (XCDR (tem)));
 27307                         tem = XCDR (XCDR (tem));
 27308                       }
 27309                     props = oprops;
 27310                   }
 27311 
 27312                 aelt = Fassoc (elt, mode_line_proptrans_alist, Qnil);
 27313                 if (! NILP (aelt) && !NILP (Fequal (props, XCDR (aelt))))
 27314                   {
 27315                     /* AELT is what we want.  Move it to the front
 27316                        without consing.  */
 27317                     elt = XCAR (aelt);
 27318                     mode_line_proptrans_alist
 27319                       = move_elt_to_front (aelt, mode_line_proptrans_alist);
 27320                   }
 27321                 else
 27322                   {
 27323                     Lisp_Object tem;
 27324 
 27325                     /* If AELT has the wrong props, it is useless.
 27326                        so get rid of it.  */
 27327                     if (! NILP (aelt))
 27328                       mode_line_proptrans_alist
 27329                         = Fdelq (aelt, mode_line_proptrans_alist);
 27330 
 27331                     elt = Fcopy_sequence (elt);
 27332                     /* PROPS might cause set-text-properties to signal
 27333                        an error, so we call it via internal_condition_case_n,
 27334                        to avoid an infloop in redisplay due to the error.  */
 27335                     internal_condition_case_n (safe_set_text_properties,
 27336                                                4,
 27337                                                ((Lisp_Object [])
 27338                                                {make_fixnum (0),
 27339                                                    Flength (elt),
 27340                                                    props,
 27341                                                    elt}),
 27342                                                Qt, safe_eval_handler);
 27343                     /* Add this item to mode_line_proptrans_alist.  */
 27344                     mode_line_proptrans_alist
 27345                       = Fcons (Fcons (elt, props),
 27346                                mode_line_proptrans_alist);
 27347                     /* Truncate mode_line_proptrans_alist
 27348                        to at most 50 elements.  */
 27349                     tem = Fnthcdr (make_fixnum (50),
 27350                                    mode_line_proptrans_alist);
 27351                     if (! NILP (tem))
 27352                       XSETCDR (tem, Qnil);
 27353                   }
 27354               }
 27355           }
 27356 
 27357         offset = 0;
 27358 
 27359         if (literal)
 27360           {
 27361             prec = precision - n;
 27362             switch (mode_line_target)
 27363               {
 27364               case MODE_LINE_NOPROP:
 27365               case MODE_LINE_TITLE:
 27366                 n += store_mode_line_noprop (SSDATA (elt), -1, prec);
 27367                 break;
 27368               case MODE_LINE_STRING:
 27369                 n += store_mode_line_string (NULL, elt, true, 0, prec, Qnil);
 27370                 break;
 27371               case MODE_LINE_DISPLAY:
 27372                 n += display_string (NULL, elt, Qnil, 0, 0, it,
 27373                                      0, prec, 0, STRING_MULTIBYTE (elt));
 27374                 break;
 27375               }
 27376 
 27377             break;
 27378           }
 27379 
 27380         /* Handle the non-literal case.  */
 27381 
 27382         while ((precision <= 0 || n < precision)
 27383                && SREF (elt, offset) != 0
 27384                && (mode_line_target != MODE_LINE_DISPLAY
 27385                    || it->current_x < it->last_visible_x))
 27386           {
 27387             ptrdiff_t last_offset = offset;
 27388 
 27389             /* Advance to end of string or next format specifier.  */
 27390             while ((c = SREF (elt, offset++)) != '\0' && c != '%')
 27391               ;
 27392 
 27393             if (offset - 1 != last_offset)
 27394               {
 27395                 ptrdiff_t nchars, nbytes;
 27396 
 27397                 /* Output to end of string or up to '%'.  Field width
 27398                    is length of string.  Don't output more than
 27399                    PRECISION allows us.  */
 27400                 offset--;
 27401 
 27402                 prec = c_string_width (SDATA (elt) + last_offset,
 27403                                        offset - last_offset, precision - n,
 27404                                        &nchars, &nbytes);
 27405 
 27406                 switch (mode_line_target)
 27407                   {
 27408                   case MODE_LINE_NOPROP:
 27409                   case MODE_LINE_TITLE:
 27410                     n += store_mode_line_noprop (SSDATA (elt) + last_offset, 0, prec);
 27411                     break;
 27412                   case MODE_LINE_STRING:
 27413                     {
 27414                       ptrdiff_t bytepos = last_offset;
 27415                       ptrdiff_t charpos = string_byte_to_char (elt, bytepos);
 27416                       ptrdiff_t endpos = (precision <= 0
 27417                                           ? string_byte_to_char (elt, offset)
 27418                                           : charpos + nchars);
 27419                       Lisp_Object mode_string
 27420                         = Fsubstring (elt, make_fixnum (charpos),
 27421                                       make_fixnum (endpos));
 27422                       n += store_mode_line_string (NULL, mode_string, false,
 27423                                                    0, 0, Qnil);
 27424                     }
 27425                     break;
 27426                   case MODE_LINE_DISPLAY:
 27427                     {
 27428                       ptrdiff_t bytepos = last_offset;
 27429                       ptrdiff_t charpos = string_byte_to_char (elt, bytepos);
 27430 
 27431                       if (precision <= 0)
 27432                         nchars = string_byte_to_char (elt, offset) - charpos;
 27433                       n += display_string (NULL, elt, Qnil, 0, charpos,
 27434                                            it, 0, nchars, 0,
 27435                                            STRING_MULTIBYTE (elt));
 27436                     }
 27437                     break;
 27438                   }
 27439               }
 27440             else /* c == '%' */
 27441               {
 27442                 ptrdiff_t percent_position = offset;
 27443 
 27444                 /* Get the specified minimum width.  Zero means
 27445                    don't pad.  */
 27446                 field = 0;
 27447                 while ((c = SREF (elt, offset++)) >= '0' && c <= '9')
 27448                   field = field * 10 + c - '0';
 27449 
 27450                 /* Don't pad beyond the total padding allowed.  */
 27451                 if (field_width - n > 0 && field > field_width - n)
 27452                   field = field_width - n;
 27453 
 27454                 /* Note that either PRECISION <= 0 or N < PRECISION.  */
 27455                 prec = precision - n;
 27456 
 27457                 if (c == 'M')
 27458                   n += display_mode_element (it, depth, field, prec,
 27459                                              Vglobal_mode_string, props,
 27460                                              risky);
 27461                 else if (c != 0)
 27462                   {
 27463                     bool multibyte;
 27464                     ptrdiff_t bytepos, charpos;
 27465                     const char *spec;
 27466                     Lisp_Object string;
 27467 
 27468                     bytepos = percent_position;
 27469                     charpos = (STRING_MULTIBYTE (elt)
 27470                                ? string_byte_to_char (elt, bytepos)
 27471                                : bytepos);
 27472                     spec = decode_mode_spec (it->w, c, field, &string);
 27473                     eassert (NILP (string) || STRINGP (string));
 27474                     multibyte = !NILP (string) && STRING_MULTIBYTE (string);
 27475                     /* Non-ASCII characters in SPEC should cause mode-line
 27476                        element be displayed as a multibyte string.  */
 27477                     ptrdiff_t nbytes = strlen (spec);
 27478                     ptrdiff_t nchars, mb_nbytes;
 27479                     parse_str_as_multibyte ((const unsigned char *)spec, nbytes,
 27480                                             &nchars, &mb_nbytes);
 27481                     if (!(nbytes == nchars || nbytes != mb_nbytes))
 27482                       multibyte = true;
 27483 
 27484                     switch (mode_line_target)
 27485                       {
 27486                       case MODE_LINE_NOPROP:
 27487                       case MODE_LINE_TITLE:
 27488                         n += store_mode_line_noprop (spec, field, prec);
 27489                         break;
 27490                       case MODE_LINE_STRING:
 27491                         {
 27492                           Lisp_Object tem = build_string (spec);
 27493                           props = Ftext_properties_at (make_fixnum (charpos), elt);
 27494                           /* Should only keep face property in props */
 27495                           n += store_mode_line_string (NULL, tem, false,
 27496                                                        field, prec, props);
 27497                         }
 27498                         break;
 27499                       case MODE_LINE_DISPLAY:
 27500                         {
 27501                           int nglyphs_before, nwritten;
 27502 
 27503                           nglyphs_before = it->glyph_row->used[TEXT_AREA];
 27504                           nwritten = display_string (spec, string, elt,
 27505                                                      charpos, 0, it,
 27506                                                      field, prec, 0,
 27507                                                      multibyte);
 27508 
 27509                           /* Assign to the glyphs written above the
 27510                              string where the `%x' came from, position
 27511                              of the `%'.  */
 27512                           if (nwritten > 0)
 27513                             {
 27514                               struct glyph *glyph
 27515                                 = (it->glyph_row->glyphs[TEXT_AREA]
 27516                                    + nglyphs_before);
 27517                               int i;
 27518 
 27519                               for (i = 0; i < nwritten; ++i)
 27520                                 {
 27521                                   glyph[i].object = elt;
 27522                                   glyph[i].charpos = charpos;
 27523                                 }
 27524 
 27525                               n += nwritten;
 27526                             }
 27527                         }
 27528                         break;
 27529                       }
 27530                   }
 27531                 else /* c == 0 */
 27532                   break;
 27533               }
 27534           }
 27535       }
 27536       break;
 27537 
 27538     case Lisp_Symbol:
 27539       /* A symbol: process the value of the symbol recursively
 27540          as if it appeared here directly.  Avoid error if symbol void.
 27541          Special case: if value of symbol is a string, output the string
 27542          literally.  */
 27543       {
 27544         register Lisp_Object tem;
 27545 
 27546         /* If the variable is not marked as risky to set
 27547            then its contents are risky to use.  */
 27548         if (NILP (Fget (elt, Qrisky_local_variable)))
 27549           risky = true;
 27550 
 27551         tem = Fboundp (elt);
 27552         if (!NILP (tem))
 27553           {
 27554             tem = Fsymbol_value (elt);
 27555             /* If value is a string, output that string literally:
 27556                don't check for % within it.  */
 27557             if (STRINGP (tem))
 27558               literal = true;
 27559 
 27560             if (!EQ (tem, elt))
 27561               {
 27562                 /* Give up right away for nil or t.  */
 27563                 elt = tem;
 27564                 goto tail_recurse;
 27565               }
 27566           }
 27567       }
 27568       break;
 27569 
 27570     case Lisp_Cons:
 27571       {
 27572         register Lisp_Object car, tem;
 27573 
 27574         /* A cons cell: five distinct cases.
 27575            If first element is :eval or :propertize, do something special.
 27576            If first element is a string or a cons, process all the elements
 27577            and effectively concatenate them.
 27578            If first element is a negative number, truncate displaying cdr to
 27579            at most that many characters.  If positive, pad (with spaces)
 27580            to at least that many characters.
 27581            If first element is a symbol, process the cadr or caddr recursively
 27582            according to whether the symbol's value is non-nil or nil.  */
 27583         car = XCAR (elt);
 27584         if (EQ (car, QCeval))
 27585           {
 27586             /* An element of the form (:eval FORM) means evaluate FORM
 27587                and use the result as mode line elements.  */
 27588 
 27589             if (risky)
 27590               break;
 27591 
 27592             if (CONSP (XCDR (elt)))
 27593               {
 27594                 Lisp_Object spec;
 27595                 spec = safe__eval (true, XCAR (XCDR (elt)));
 27596                 /* The :eval form could delete the frame stored in the
 27597                    iterator, which will cause a crash if we try to
 27598                    access faces and other fields (e.g., FRAME_KBOARD)
 27599                    on that frame.  This is a nonsensical thing to do,
 27600                    and signaling an error from redisplay might be
 27601                    dangerous, but we cannot continue with an invalid frame.  */
 27602                 if (!FRAME_LIVE_P (it->f))
 27603                   signal_error (":eval deleted the frame being displayed", elt);
 27604                 n += display_mode_element (it, depth, field_width - n,
 27605                                            precision - n, spec, props,
 27606                                            risky);
 27607               }
 27608           }
 27609         else if (EQ (car, QCpropertize))
 27610           {
 27611             /* An element of the form (:propertize ELT PROPS...)
 27612                means display ELT but applying properties PROPS.  */
 27613 
 27614             if (risky)
 27615               break;
 27616 
 27617             if (CONSP (XCDR (elt)))
 27618               n += display_mode_element (it, depth, field_width - n,
 27619                                          precision - n, XCAR (XCDR (elt)),
 27620                                          XCDR (XCDR (elt)), risky);
 27621           }
 27622         else if (SYMBOLP (car))
 27623           {
 27624             tem = Fboundp (car);
 27625             elt = XCDR (elt);
 27626             if (!CONSP (elt))
 27627               goto invalid;
 27628             /* elt is now the cdr, and we know it is a cons cell.
 27629                Use its car if CAR has a non-nil value.  */
 27630             if (!NILP (tem))
 27631               {
 27632                 tem = Fsymbol_value (car);
 27633                 if (!NILP (tem))
 27634                   {
 27635                     elt = XCAR (elt);
 27636                     goto tail_recurse;
 27637                   }
 27638               }
 27639             /* Symbol's value is nil (or symbol is unbound)
 27640                Get the cddr of the original list
 27641                and if possible find the caddr and use that.  */
 27642             elt = XCDR (elt);
 27643             if (NILP (elt))
 27644               break;
 27645             else if (!CONSP (elt))
 27646               goto invalid;
 27647             elt = XCAR (elt);
 27648             goto tail_recurse;
 27649           }
 27650         else if (FIXNUMP (car))
 27651           {
 27652             register int lim = XFIXNUM (car);
 27653             elt = XCDR (elt);
 27654             if (lim < 0)
 27655               {
 27656                 /* Negative int means reduce maximum width.  */
 27657                 if (precision <= 0)
 27658                   precision = -lim;
 27659                 else
 27660                   precision = min (precision, -lim);
 27661               }
 27662             else if (lim > 0)
 27663               {
 27664                 /* Padding specified.  Don't let it be more than
 27665                    current maximum.  */
 27666                 if (precision > 0)
 27667                   lim = min (precision, lim);
 27668 
 27669                 /* If that's more padding than already wanted, queue it.
 27670                    But don't reduce padding already specified even if
 27671                    that is beyond the current truncation point.  */
 27672                 field_width = max (lim, field_width);
 27673               }
 27674             goto tail_recurse;
 27675           }
 27676         else if (STRINGP (car) || CONSP (car))
 27677           FOR_EACH_TAIL_SAFE (elt)
 27678             {
 27679               if (0 < precision && precision <= n)
 27680                 break;
 27681               n += display_mode_element (it, depth,
 27682                                          /* Pad after only the last
 27683                                             list element.  */
 27684                                          (! CONSP (XCDR (elt))
 27685                                           ? field_width - n
 27686                                           : 0),
 27687                                          precision - n, XCAR (elt),
 27688                                          props, risky);
 27689             }
 27690       }
 27691       break;
 27692 
 27693     default:
 27694     invalid:
 27695       elt = build_string ("*invalid*");
 27696       goto tail_recurse;
 27697     }
 27698 
 27699   /* Pad to FIELD_WIDTH.  */
 27700   if (field_width > 0 && n < field_width)
 27701     {
 27702       switch (mode_line_target)
 27703         {
 27704         case MODE_LINE_NOPROP:
 27705         case MODE_LINE_TITLE:
 27706           n += store_mode_line_noprop ("", field_width - n, 0);
 27707           break;
 27708         case MODE_LINE_STRING:
 27709           n += store_mode_line_string ("", Qnil, false, field_width - n, 0,
 27710                                        Qnil);
 27711           break;
 27712         case MODE_LINE_DISPLAY:
 27713           n += display_string ("", Qnil, Qnil, 0, 0, it, field_width - n,
 27714                                0, 0, 0);
 27715           break;
 27716         }
 27717     }
 27718 
 27719   return n;
 27720 }
 27721 
 27722 /* Store a mode-line string element in mode_line_string_list.
 27723 
 27724    If STRING is non-null, display that C string.  Otherwise, the Lisp
 27725    string LISP_STRING is displayed.
 27726 
 27727    FIELD_WIDTH is the minimum number of output glyphs to produce.
 27728    If STRING has fewer characters than FIELD_WIDTH, pad to the right
 27729    with spaces.  FIELD_WIDTH <= 0 means don't pad.
 27730 
 27731    PRECISION is the maximum number of characters to output from
 27732    STRING.  PRECISION <= 0  means don't truncate the string.
 27733 
 27734    If COPY_STRING, make a copy of LISP_STRING before adding
 27735    properties to the string.
 27736 
 27737    PROPS are the properties to add to the string.
 27738    The mode_line_string_face face property is always added to the string.
 27739  */
 27740 
 27741 static int
 27742 store_mode_line_string (const char *string, Lisp_Object lisp_string,
 27743                         bool copy_string,
 27744                         int field_width, int precision, Lisp_Object props)
 27745 {
 27746   ptrdiff_t len;
 27747   int n = 0;
 27748 
 27749   if (string != NULL)
 27750     {
 27751       len = strnlen (string, precision <= 0 ? SIZE_MAX : precision);
 27752       lisp_string = make_string (string, len);
 27753       if (NILP (props))
 27754         props = mode_line_string_face_prop;
 27755       else if (!NILP (mode_line_string_face))
 27756         {
 27757           Lisp_Object face = plist_get (props, Qface);
 27758           props = Fcopy_sequence (props);
 27759           if (NILP (face))
 27760             face = mode_line_string_face;
 27761           else
 27762             face = list2 (face, mode_line_string_face);
 27763           props = plist_put (props, Qface, face);
 27764         }
 27765       Fadd_text_properties (make_fixnum (0), make_fixnum (len),
 27766                             props, lisp_string);
 27767     }
 27768   else
 27769     {
 27770       len = SCHARS (lisp_string);
 27771       if (precision > 0 && len > precision)
 27772         {
 27773           len = precision;
 27774           lisp_string = Fsubstring (lisp_string, make_fixnum (0), make_fixnum (len));
 27775           precision = -1;
 27776         }
 27777       if (!NILP (mode_line_string_face))
 27778         {
 27779           Lisp_Object face;
 27780           if (NILP (props))
 27781             props = Ftext_properties_at (make_fixnum (0), lisp_string);
 27782           face = plist_get (props, Qface);
 27783           if (NILP (face))
 27784             face = mode_line_string_face;
 27785           else
 27786             face = list2 (face, mode_line_string_face);
 27787           props = list2 (Qface, face);
 27788           if (copy_string)
 27789             lisp_string = Fcopy_sequence (lisp_string);
 27790         }
 27791       if (!NILP (props))
 27792         Fadd_text_properties (make_fixnum (0), make_fixnum (len),
 27793                               props, lisp_string);
 27794     }
 27795 
 27796   if (len > 0)
 27797     {
 27798       mode_line_string_list = Fcons (lisp_string, mode_line_string_list);
 27799       n += len;
 27800     }
 27801 
 27802   if (field_width > len)
 27803     {
 27804       field_width -= len;
 27805       lisp_string = Fmake_string (make_fixnum (field_width), make_fixnum (' '),
 27806                                   Qnil);
 27807       if (!NILP (props))
 27808         Fadd_text_properties (make_fixnum (0), make_fixnum (field_width),
 27809                               props, lisp_string);
 27810       mode_line_string_list = Fcons (lisp_string, mode_line_string_list);
 27811       n += field_width;
 27812     }
 27813 
 27814   return n;
 27815 }
 27816 
 27817 
 27818 DEFUN ("format-mode-line", Fformat_mode_line, Sformat_mode_line,
 27819        1, 4, 0,
 27820        doc: /* Format a string out of a mode line format specification.
 27821 First arg FORMAT specifies the mode line format (see `mode-line-format'
 27822 for details) to use.
 27823 
 27824 By default, the format is evaluated for the currently selected window.
 27825 
 27826 Optional second arg FACE specifies the face property to put on all
 27827 characters for which no face is specified.  The value nil means the
 27828 default face.  The value t means whatever face the window's mode line
 27829 currently uses (either `mode-line' or `mode-line-inactive',
 27830 depending on whether the window is the selected window or not).
 27831 An integer value means the value string has no text
 27832 properties.
 27833 
 27834 Optional third and fourth args WINDOW and BUFFER specify the window
 27835 and buffer to use as the context for the formatting (defaults
 27836 are the selected window and the WINDOW's buffer).  */)
 27837      (Lisp_Object format, Lisp_Object face,
 27838       Lisp_Object window, Lisp_Object buffer)
 27839 {
 27840   struct it it;
 27841   int len;
 27842   struct window *w;
 27843   struct buffer *old_buffer = NULL;
 27844   int face_id;
 27845   bool no_props = FIXNUMP (face);
 27846   specpdl_ref count = SPECPDL_INDEX ();
 27847   Lisp_Object str;
 27848   int string_start = 0;
 27849 
 27850   w = decode_any_window (window);
 27851   XSETWINDOW (window, w);
 27852 
 27853   if (NILP (buffer))
 27854     buffer = w->contents;
 27855   CHECK_BUFFER (buffer);
 27856 
 27857   /* Make formatting the modeline a non-op when noninteractive, otherwise
 27858      there will be problems later caused by a partially initialized frame.  */
 27859   if (NILP (format) || noninteractive)
 27860     return empty_unibyte_string;
 27861 
 27862   if (no_props)
 27863     face = Qnil;
 27864 
 27865   face_id = (NILP (face) || EQ (face, Qdefault)) ? DEFAULT_FACE_ID
 27866     : EQ (face, Qt) ? (EQ (window, selected_window)
 27867                        ? MODE_LINE_ACTIVE_FACE_ID : MODE_LINE_INACTIVE_FACE_ID)
 27868     : EQ (face, Qmode_line_active) ? MODE_LINE_ACTIVE_FACE_ID
 27869     : EQ (face, Qmode_line_inactive) ? MODE_LINE_INACTIVE_FACE_ID
 27870     : EQ (face, Qheader_line) ? HEADER_LINE_FACE_ID
 27871     : EQ (face, Qtab_line) ? TAB_LINE_FACE_ID
 27872     : EQ (face, Qtab_bar) ? TAB_BAR_FACE_ID
 27873     : EQ (face, Qtool_bar) ? TOOL_BAR_FACE_ID
 27874     : DEFAULT_FACE_ID;
 27875 
 27876   old_buffer = current_buffer;
 27877 
 27878   /* Save things including mode_line_proptrans_alist,
 27879      and set that to nil so that we don't alter the outer value.  */
 27880   record_unwind_protect (unwind_format_mode_line,
 27881                          format_mode_line_unwind_data
 27882                            (XFRAME (WINDOW_FRAME (w)),
 27883                             old_buffer, selected_window, true));
 27884   mode_line_proptrans_alist = Qnil;
 27885 
 27886   Fselect_window (window, Qt);
 27887   set_buffer_internal_1 (XBUFFER (buffer));
 27888 
 27889   init_iterator (&it, w, -1, -1, NULL, face_id);
 27890 
 27891   if (no_props)
 27892     {
 27893       mode_line_target = MODE_LINE_NOPROP;
 27894       mode_line_string_face_prop = Qnil;
 27895       mode_line_string_list = Qnil;
 27896       string_start = MODE_LINE_NOPROP_LEN (0);
 27897     }
 27898   else
 27899     {
 27900       mode_line_target = MODE_LINE_STRING;
 27901       mode_line_string_list = Qnil;
 27902       mode_line_string_face = face;
 27903       mode_line_string_face_prop
 27904         = NILP (face) ? Qnil : list2 (Qface, face);
 27905     }
 27906 
 27907   push_kboard (FRAME_KBOARD (it.f));
 27908   display_mode_element (&it, 0, 0, 0, format, Qnil, false);
 27909   pop_kboard ();
 27910 
 27911   if (no_props)
 27912     {
 27913       len = MODE_LINE_NOPROP_LEN (string_start);
 27914       str = make_string (mode_line_noprop_buf + string_start, len);
 27915     }
 27916   else
 27917     {
 27918       mode_line_string_list = Fnreverse (mode_line_string_list);
 27919       str = Fmapconcat (Qidentity, mode_line_string_list,
 27920                         empty_unibyte_string);
 27921     }
 27922 
 27923   return unbind_to (count, str);
 27924 }
 27925 
 27926 /* Write a null-terminated, right justified decimal representation of
 27927    the positive integer D to BUF using a minimal field width WIDTH.  */
 27928 
 27929 static void
 27930 pint2str (register char *buf, register int width, register ptrdiff_t d)
 27931 {
 27932   register char *p = buf;
 27933 
 27934   if (d <= 0)
 27935     *p++ = '0';
 27936   else
 27937     {
 27938       while (d > 0)
 27939         {
 27940           *p++ = d % 10 + '0';
 27941           d /= 10;
 27942         }
 27943     }
 27944 
 27945   for (width -= (int) (p - buf); width > 0; --width)
 27946     *p++ = ' ';
 27947   *p-- = '\0';
 27948   while (p > buf)
 27949     {
 27950       d = *buf;
 27951       *buf++ = *p;
 27952       *p-- = d;
 27953     }
 27954 }
 27955 
 27956 /* Write a null-terminated, right justified decimal and "human
 27957    readable" representation of the nonnegative integer D to BUF using
 27958    a minimal field width WIDTH.  D should be smaller than 999.5e24. */
 27959 
 27960 static const char power_letter[] =
 27961   {
 27962     0,   /* no letter */
 27963     'k', /* kilo */
 27964     'M', /* mega */
 27965     'G', /* giga */
 27966     'T', /* tera */
 27967     'P', /* peta */
 27968     'E', /* exa */
 27969     'Z', /* zetta */
 27970     'Y', /* yotta */
 27971     'R', /* ronna */
 27972     'Q'  /* quetta */
 27973   };
 27974 
 27975 static void
 27976 pint2hrstr (char *buf, int width, ptrdiff_t d)
 27977 {
 27978   /* We aim to represent the nonnegative integer D as
 27979      QUOTIENT.TENTHS * 10 ^ (3 * EXPONENT). */
 27980   ptrdiff_t quotient = d;
 27981   int remainder = 0;
 27982   /* -1 means: do not use TENTHS. */
 27983   int tenths = -1;
 27984   int exponent = 0;
 27985 
 27986   /* Length of QUOTIENT.TENTHS as a string. */
 27987   int length;
 27988 
 27989   char * psuffix;
 27990   char * p;
 27991 
 27992   if (quotient >= 1000)
 27993     {
 27994       /* Scale to the appropriate EXPONENT. */
 27995       do
 27996         {
 27997           remainder = quotient % 1000;
 27998           quotient /= 1000;
 27999           exponent++;
 28000         }
 28001       while (quotient >= 1000);
 28002 
 28003       /* Round to nearest and decide whether to use TENTHS or not. */
 28004       if (quotient <= 9)
 28005         {
 28006           tenths = remainder / 100;
 28007           if (remainder % 100 >= 50)
 28008             {
 28009               if (tenths < 9)
 28010                 tenths++;
 28011               else
 28012                 {
 28013                   quotient++;
 28014                   if (quotient == 10)
 28015                     tenths = -1;
 28016                   else
 28017                     tenths = 0;
 28018                 }
 28019             }
 28020         }
 28021       else
 28022         if (remainder >= 500)
 28023           {
 28024             if (quotient < 999)
 28025               quotient++;
 28026             else
 28027               {
 28028                 quotient = 1;
 28029                 exponent++;
 28030                 tenths = 0;
 28031               }
 28032           }
 28033     }
 28034 
 28035   /* Calculate the LENGTH of QUOTIENT.TENTHS as a string. */
 28036   if (tenths == -1 && quotient <= 99)
 28037     if (quotient <= 9)
 28038       length = 1;
 28039     else
 28040       length = 2;
 28041   else
 28042     length = 3;
 28043   p = psuffix = buf + max (width, length);
 28044 
 28045   /* Print EXPONENT. */
 28046   *psuffix++ = power_letter[exponent];
 28047   *psuffix = '\0';
 28048 
 28049   /* Print TENTHS. */
 28050   if (tenths >= 0)
 28051     {
 28052       *--p = '0' + tenths;
 28053       *--p = '.';
 28054     }
 28055 
 28056   /* Print QUOTIENT. */
 28057   do
 28058     {
 28059       int digit = quotient % 10;
 28060       *--p =  '0' + digit;
 28061     }
 28062   while ((quotient /= 10) != 0);
 28063 
 28064   /* Print leading spaces. */
 28065   while (buf < p)
 28066     *--p = ' ';
 28067 }
 28068 
 28069 /* Set a mnemonic character for coding_system (Lisp symbol) in BUF.
 28070    If EOL_FLAG, set also a mnemonic character for end-of-line
 28071    type of CODING_SYSTEM.  Return updated pointer into BUF.  */
 28072 
 28073 static unsigned char invalid_eol_type[] = "(*invalid*)";
 28074 
 28075 static char *
 28076 decode_mode_spec_coding (Lisp_Object coding_system, char *buf, bool eol_flag)
 28077 {
 28078   Lisp_Object val;
 28079   bool multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
 28080   const unsigned char *eol_str;
 28081   int eol_str_len;
 28082   /* The EOL conversion we are using.  */
 28083   Lisp_Object eoltype;
 28084 
 28085   val = CODING_SYSTEM_SPEC (coding_system);
 28086   eoltype = Qnil;
 28087 
 28088   if (!VECTORP (val))           /* Not yet decided.  */
 28089     {
 28090       *buf++ = multibyte ? '-' : ' ';
 28091       if (eol_flag)
 28092         eoltype = eol_mnemonic_undecided;
 28093       /* Don't mention EOL conversion if it isn't decided.  */
 28094     }
 28095   else
 28096     {
 28097       Lisp_Object attrs;
 28098       Lisp_Object eolvalue;
 28099 
 28100       attrs = AREF (val, 0);
 28101       eolvalue = AREF (val, 2);
 28102 
 28103       if (multibyte)
 28104         buf += CHAR_STRING (XFIXNAT (CODING_ATTR_MNEMONIC (attrs)),
 28105                             (unsigned char *) buf);
 28106       else
 28107         *buf++ = ' ';
 28108 
 28109       if (eol_flag)
 28110         {
 28111           /* The EOL conversion that is normal on this system.  */
 28112 
 28113           if (NILP (eolvalue))  /* Not yet decided.  */
 28114             eoltype = eol_mnemonic_undecided;
 28115           else if (VECTORP (eolvalue)) /* Not yet decided.  */
 28116             eoltype = eol_mnemonic_undecided;
 28117           else                  /* eolvalue is Qunix, Qdos, or Qmac.  */
 28118             eoltype = (EQ (eolvalue, Qunix)
 28119                        ? eol_mnemonic_unix
 28120                        : EQ (eolvalue, Qdos)
 28121                        ? eol_mnemonic_dos : eol_mnemonic_mac);
 28122         }
 28123     }
 28124 
 28125   if (eol_flag)
 28126     {
 28127       /* Mention the EOL conversion if it is not the usual one.  */
 28128       if (STRINGP (eoltype))
 28129         {
 28130           eol_str = SDATA (eoltype);
 28131           eol_str_len = SBYTES (eoltype);
 28132         }
 28133       else if (CHARACTERP (eoltype))
 28134         {
 28135           int c = XFIXNAT (eoltype);
 28136           return buf + CHAR_STRING (c, (unsigned char *) buf);
 28137         }
 28138       else
 28139         {
 28140           eol_str = invalid_eol_type;
 28141           eol_str_len = sizeof (invalid_eol_type) - 1;
 28142         }
 28143       memcpy (buf, eol_str, eol_str_len);
 28144       buf += eol_str_len;
 28145     }
 28146 
 28147   return buf;
 28148 }
 28149 
 28150 /* Return the approximate percentage N is of D (rounding upward), or 99,
 28151    whichever is less.  Assume 0 < D and 0 <= N <= D * INT_MAX / 100.  */
 28152 
 28153 static int
 28154 percent99 (ptrdiff_t n, ptrdiff_t d)
 28155 {
 28156   int percent = (d - 1 + 100.0 * n) / d;
 28157   return min (percent, 99);
 28158 }
 28159 
 28160 /* Return a string for the output of a mode line %-spec for window W,
 28161    generated by character C.  FIELD_WIDTH > 0 means pad the string
 28162    returned with spaces to that value.  Set *STRING to be a Lisp
 28163    string if the resulting string is taken from that Lisp string;
 28164    otherwise, set *STRING to Qnil.
 28165 
 28166    Note we operate on the current buffer for most purposes.  */
 28167 
 28168 static char lots_of_dashes[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
 28169 
 28170 static const char *
 28171 decode_mode_spec (struct window *w, register int c, int field_width,
 28172                   Lisp_Object *string)
 28173 {
 28174   Lisp_Object obj;
 28175   struct frame *f = XFRAME (WINDOW_FRAME (w));
 28176   char *decode_mode_spec_buf = f->decode_mode_spec_buffer;
 28177   /* We are going to use f->decode_mode_spec_buffer as the buffer to
 28178      produce strings from numerical values, so limit preposterously
 28179      large values of FIELD_WIDTH to avoid overrunning the buffer's
 28180      end.  The size of the buffer is enough for FRAME_MESSAGE_BUF_SIZE
 28181      bytes plus the terminating null.  */
 28182   int width = min (field_width, FRAME_MESSAGE_BUF_SIZE (f));
 28183   struct buffer *b = current_buffer;
 28184 
 28185   obj = Qnil;
 28186   *string = Qnil;
 28187 
 28188   switch (c)
 28189     {
 28190     case '*':
 28191       if (!NILP (BVAR (b, read_only)))
 28192         return "%";
 28193       if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
 28194         return "*";
 28195       return "-";
 28196 
 28197     case '+':
 28198       /* This differs from %* only for a modified read-only buffer.  */
 28199       if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
 28200         return "*";
 28201       if (!NILP (BVAR (b, read_only)))
 28202         return "%";
 28203       return "-";
 28204 
 28205     case '&':
 28206       /* This differs from %* in ignoring read-only-ness.  */
 28207       if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
 28208         return "*";
 28209       return "-";
 28210 
 28211     case '%':
 28212       return "%";
 28213 
 28214     case '[':
 28215       {
 28216         int i;
 28217         char *p;
 28218 
 28219         if (command_loop_level > 5)
 28220           return "[[[... ";
 28221         p = decode_mode_spec_buf;
 28222         for (i = 0; i < command_loop_level; i++)
 28223           *p++ = '[';
 28224         *p = 0;
 28225         return decode_mode_spec_buf;
 28226       }
 28227 
 28228     case ']':
 28229       {
 28230         int i;
 28231         char *p;
 28232 
 28233         if (command_loop_level > 5)
 28234           return " ...]]]";
 28235         p = decode_mode_spec_buf;
 28236         for (i = 0; i < command_loop_level; i++)
 28237           *p++ = ']';
 28238         *p = 0;
 28239         return decode_mode_spec_buf;
 28240       }
 28241 
 28242     case '-':
 28243       {
 28244         register int i;
 28245 
 28246         /* Let lots_of_dashes be a string of infinite length.  */
 28247         if (mode_line_target == MODE_LINE_NOPROP
 28248             || mode_line_target == MODE_LINE_STRING)
 28249           return "--";
 28250         if (field_width <= 0
 28251             || field_width > sizeof (lots_of_dashes))
 28252           {
 28253             for (i = 0; i < FRAME_MESSAGE_BUF_SIZE (f) - 1; ++i)
 28254               decode_mode_spec_buf[i] = '-';
 28255             decode_mode_spec_buf[i] = '\0';
 28256             return decode_mode_spec_buf;
 28257           }
 28258         else
 28259           return lots_of_dashes;
 28260       }
 28261 
 28262     case 'b':
 28263       obj = BVAR (b, name);
 28264       break;
 28265 
 28266     case 'c':
 28267     case 'C':
 28268       /* %c, %C, and %l are ignored in `frame-title-format'.
 28269          (In redisplay_internal, the frame title is drawn _before_ the
 28270          windows are updated, so the stuff which depends on actual
 28271          window contents (such as %l) may fail to render properly, or
 28272          even crash emacs.)  */
 28273       if (mode_line_target == MODE_LINE_TITLE)
 28274         return "";
 28275       else
 28276         {
 28277           ptrdiff_t col = current_column ();
 28278           int disp_col = (c == 'C') ? col + 1 : col;
 28279           w->column_number_displayed = col;
 28280           pint2str (decode_mode_spec_buf, width, disp_col);
 28281           return decode_mode_spec_buf;
 28282         }
 28283 
 28284     case 'e':
 28285 #if !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
 28286       {
 28287         if (NILP (Vmemory_full))
 28288           return "";
 28289         else
 28290           return "!MEM FULL! ";
 28291       }
 28292 #else
 28293       return "";
 28294 #endif
 28295 
 28296     case 'F':
 28297       /* %F displays the frame name.  */
 28298       if (!NILP (f->title))
 28299         return SSDATA (f->title);
 28300       if (f->explicit_name || ! FRAME_WINDOW_P (f))
 28301         return SSDATA (f->name);
 28302       return "Emacs";
 28303 
 28304     case 'f':
 28305       obj = BVAR (b, filename);
 28306       break;
 28307 
 28308     case 'i':
 28309       {
 28310         ptrdiff_t size = ZV - BEGV;
 28311         pint2str (decode_mode_spec_buf, width, size);
 28312         return decode_mode_spec_buf;
 28313       }
 28314 
 28315     case 'I':
 28316       {
 28317         ptrdiff_t size = ZV - BEGV;
 28318         pint2hrstr (decode_mode_spec_buf, width, size);
 28319         return decode_mode_spec_buf;
 28320       }
 28321 
 28322     case 'l':
 28323       {
 28324         ptrdiff_t startpos, startpos_byte, line, linepos, linepos_byte;
 28325         ptrdiff_t topline, nlines, height;
 28326         ptrdiff_t junk;
 28327 
 28328         /* %c, %C, and %l are ignored in `frame-title-format'.  */
 28329         if (mode_line_target == MODE_LINE_TITLE)
 28330           return "";
 28331 
 28332         startpos = marker_position (w->start);
 28333         startpos_byte = marker_byte_position (w->start);
 28334         height = WINDOW_TOTAL_LINES (w);
 28335         /* We cannot cope with w->start being outside of the
 28336            accessible portion of the buffer; in particular,
 28337            display_count_lines call below might infloop if called with
 28338            startpos_byte outside of the [BEGV_BYTE..ZV_BYTE] region.
 28339            Such w->start means we were called in some "creative" way
 28340            when the buffer's restriction was changed, but the window
 28341            wasn't yet redisplayed after that.  If that happens, we
 28342            need to determine a new base line.  */
 28343         if (!(BUF_BEGV_BYTE (b) <= startpos_byte
 28344               && startpos_byte <= BUF_ZV_BYTE (b)))
 28345           {
 28346             startpos = BUF_BEGV (b);
 28347             startpos_byte = BUF_BEGV_BYTE (b);
 28348             w->base_line_pos = 0;
 28349             w->base_line_number = 0;
 28350           }
 28351 
 28352         /* If we decided that this buffer isn't suitable for line numbers,
 28353            don't forget that too fast.  */
 28354         if (w->base_line_pos == -1)
 28355           goto no_value;
 28356 
 28357         /* If the buffer is very big, don't waste time.  */
 28358         if (FIXNUMP (Vline_number_display_limit)
 28359             && BUF_ZV (b) - BUF_BEGV (b) > XFIXNUM (Vline_number_display_limit))
 28360           {
 28361             w->base_line_pos = 0;
 28362             w->base_line_number = 0;
 28363             goto no_value;
 28364           }
 28365 
 28366         if (w->base_line_number > 0
 28367             && w->base_line_pos > 0
 28368             && w->base_line_pos <= startpos)
 28369           {
 28370             line = w->base_line_number;
 28371             linepos = w->base_line_pos;
 28372             linepos_byte = buf_charpos_to_bytepos (b, linepos);
 28373           }
 28374         else
 28375           {
 28376             line = 1;
 28377             linepos = BUF_BEGV (b);
 28378             linepos_byte = BUF_BEGV_BYTE (b);
 28379           }
 28380 
 28381         /* Count lines from base line to window start position.  */
 28382         nlines = display_count_lines (linepos_byte,
 28383                                       startpos_byte,
 28384                                       startpos, &junk);
 28385 
 28386         topline = nlines + line;
 28387 
 28388         /* Determine a new base line, if the old one is too close
 28389            or too far away, or if we did not have one.
 28390            "Too close" means it's plausible a scroll-down would
 28391            go back past it.  */
 28392         if (startpos == BUF_BEGV (b))
 28393           {
 28394             w->base_line_number = topline;
 28395             w->base_line_pos = BUF_BEGV (b);
 28396           }
 28397         else if (nlines < height + 25 || nlines > height * 3 + 50
 28398                  || linepos == BUF_BEGV (b))
 28399           {
 28400             ptrdiff_t limit = BUF_BEGV (b);
 28401             ptrdiff_t limit_byte = BUF_BEGV_BYTE (b);
 28402             ptrdiff_t position;
 28403             ptrdiff_t distance
 28404               = (line_number_display_limit_width < 0 ? 0
 28405                  : ckd_mul (&distance, line_number_display_limit_width,
 28406                             height * 2 + 30)
 28407                  ? PTRDIFF_MAX : distance);
 28408 
 28409             if (startpos - distance > limit)
 28410               {
 28411                 limit = startpos - distance;
 28412                 limit_byte = CHAR_TO_BYTE (limit);
 28413               }
 28414 
 28415             nlines = display_count_lines (startpos_byte,
 28416                                           limit_byte,
 28417                                           - (height * 2 + 30),
 28418                                           &position);
 28419             /* If we couldn't find the lines we wanted within
 28420                line_number_display_limit_width chars per line,
 28421                give up on line numbers for this window.  */
 28422             if (position == limit_byte && limit == startpos - distance)
 28423               {
 28424                 w->base_line_pos = -1;
 28425                 w->base_line_number = 0;
 28426                 goto no_value;
 28427               }
 28428 
 28429             w->base_line_number = topline - nlines;
 28430             w->base_line_pos = BYTE_TO_CHAR (position);
 28431           }
 28432 
 28433         /* Now count lines from the start pos to point.  */
 28434         nlines = display_count_lines (startpos_byte,
 28435                                       PT_BYTE, PT, &junk);
 28436 
 28437         /* Record that we did display the line number.  */
 28438         line_number_displayed = true;
 28439 
 28440         /* Make the string to show.  */
 28441         pint2str (decode_mode_spec_buf, width, topline + nlines);
 28442         return decode_mode_spec_buf;
 28443     no_value:
 28444         {
 28445           char *p = decode_mode_spec_buf;
 28446           int pad = width - 2;
 28447           while (pad-- > 0)
 28448             *p++ = ' ';
 28449           *p++ = '?';
 28450           *p++ = '?';
 28451           *p = '\0';
 28452           return decode_mode_spec_buf;
 28453         }
 28454       }
 28455       break;
 28456 
 28457     case 'm':
 28458       obj = BVAR (b, mode_name);
 28459       break;
 28460 
 28461     case 'n':
 28462       if (BUF_BEGV (b) > BUF_BEG (b) || BUF_ZV (b) < BUF_Z (b))
 28463         return " Narrow";
 28464       break;
 28465 
 28466       /* Display the "degree of travel" of the window through the buffer.  */
 28467     case 'o':
 28468       {
 28469         ptrdiff_t toppos = marker_position (w->start);
 28470         ptrdiff_t botpos = BUF_Z (b) - w->window_end_pos;
 28471         ptrdiff_t begv = BUF_BEGV (b);
 28472         ptrdiff_t zv = BUF_ZV (b);
 28473 
 28474         if (zv <= botpos)
 28475           return toppos <= begv ? "All" : "Bottom";
 28476         else if (toppos <= begv)
 28477           return "Top";
 28478         else
 28479           {
 28480           sprintf (decode_mode_spec_buf, "%2d%%",
 28481                    percent99 (toppos - begv, (toppos - begv) + (zv - botpos)));
 28482           return decode_mode_spec_buf;
 28483           }
 28484       }
 28485 
 28486       /* Display percentage of buffer above the top of the screen.  */
 28487     case 'p':
 28488       {
 28489         ptrdiff_t pos = marker_position (w->start);
 28490         ptrdiff_t begv = BUF_BEGV (b);
 28491         ptrdiff_t zv = BUF_ZV (b);
 28492 
 28493         if (w->window_end_pos <= BUF_Z (b) - zv)
 28494           return pos <= begv ? "All" : "Bottom";
 28495         else if (pos <= begv)
 28496           return "Top";
 28497         else
 28498           {
 28499             sprintf (decode_mode_spec_buf, "%2d%%",
 28500                      percent99 (pos - begv, zv - begv));
 28501             return decode_mode_spec_buf;
 28502           }
 28503       }
 28504 
 28505       /* Display percentage of size above the bottom of the screen.  */
 28506     case 'P':
 28507       {
 28508         ptrdiff_t toppos = marker_position (w->start);
 28509         ptrdiff_t botpos = BUF_Z (b) - w->window_end_pos;
 28510         ptrdiff_t begv = BUF_BEGV (b);
 28511         ptrdiff_t zv = BUF_ZV (b);
 28512 
 28513         if (zv <= botpos)
 28514           return toppos <= begv ? "All" : "Bottom";
 28515         else
 28516           {
 28517             sprintf (decode_mode_spec_buf,
 28518                      &"Top%2d%%"[begv < toppos ? sizeof "Top" - 1 : 0],
 28519                      percent99 (botpos - begv, zv - begv));
 28520             return decode_mode_spec_buf;
 28521           }
 28522       }
 28523 
 28524       /* Display percentage offsets of top and bottom of the window,
 28525          using "All" (but not "Top" or "Bottom") where appropriate.  */
 28526     case 'q':
 28527       {
 28528         ptrdiff_t toppos = marker_position (w->start);
 28529         ptrdiff_t botpos = BUF_Z (b) - w->window_end_pos;
 28530         ptrdiff_t begv = BUF_BEGV (b);
 28531         ptrdiff_t zv = BUF_ZV (b);
 28532         int top_perc, bot_perc;
 28533 
 28534         if ((toppos <= begv) && (zv <= botpos))
 28535           return "All   ";
 28536 
 28537         top_perc = toppos <= begv ? 0 : percent99 (toppos - begv, zv - begv);
 28538         bot_perc = zv <= botpos ? 100 : percent99 (botpos - begv, zv - begv);
 28539 
 28540         if (top_perc == bot_perc)
 28541           sprintf (decode_mode_spec_buf, "%d%%", top_perc);
 28542         else
 28543           sprintf (decode_mode_spec_buf, "%d-%d%%", top_perc, bot_perc);
 28544 
 28545         return decode_mode_spec_buf;
 28546       }
 28547 
 28548     case 's':
 28549       /* status of process */
 28550       obj = Fget_buffer_process (Fcurrent_buffer ());
 28551       if (NILP (obj))
 28552         return "no process";
 28553 #ifndef MSDOS
 28554       obj = Fsymbol_name (Fprocess_status (obj));
 28555 #endif
 28556       break;
 28557 
 28558     case '@':
 28559       {
 28560         specpdl_ref count = inhibit_garbage_collection ();
 28561         Lisp_Object curdir = BVAR (current_buffer, directory);
 28562         Lisp_Object val = Qnil;
 28563 
 28564         if (STRINGP (curdir))
 28565           val = safe_call1 (intern ("file-remote-p"), curdir);
 28566 
 28567         val = unbind_to (count, val);
 28568 
 28569         if (NILP (val))
 28570           return "-";
 28571         else
 28572           return "@";
 28573       }
 28574 
 28575     case 'z':
 28576       /* coding-system (not including end-of-line format) */
 28577     case 'Z':
 28578       /* coding-system (including end-of-line type) */
 28579       {
 28580         bool eol_flag = (c == 'Z');
 28581         char *p = decode_mode_spec_buf;
 28582 
 28583         if (! FRAME_WINDOW_P (f))
 28584           {
 28585             /* No need to mention EOL here--the terminal never needs
 28586                to do EOL conversion.  */
 28587             p = decode_mode_spec_coding (CODING_ID_NAME
 28588                                          (FRAME_KEYBOARD_CODING (f)->id),
 28589                                          p, false);
 28590             p = decode_mode_spec_coding (CODING_ID_NAME
 28591                                          (FRAME_TERMINAL_CODING (f)->id),
 28592                                          p, false);
 28593           }
 28594         p = decode_mode_spec_coding (BVAR (b, buffer_file_coding_system),
 28595                                      p, eol_flag);
 28596 
 28597 #if false /* This proves to be annoying; I think we can do without. -- rms.  */
 28598 #ifdef subprocesses
 28599         obj = Fget_buffer_process (Fcurrent_buffer ());
 28600         if (PROCESSP (obj))
 28601           {
 28602             p = decode_mode_spec_coding
 28603               (XPROCESS (obj)->decode_coding_system, p, eol_flag);
 28604             p = decode_mode_spec_coding
 28605               (XPROCESS (obj)->encode_coding_system, p, eol_flag);
 28606           }
 28607 #endif /* subprocesses */
 28608 #endif /* false */
 28609         *p = 0;
 28610         return decode_mode_spec_buf;
 28611       }
 28612     }
 28613 
 28614   if (STRINGP (obj))
 28615     {
 28616       *string = obj;
 28617       return SSDATA (obj);
 28618     }
 28619   else
 28620     return "";
 28621 }
 28622 
 28623 /* Return the number of lines between start_byte and end_byte in the
 28624    current buffer. */
 28625 
 28626 ptrdiff_t
 28627 count_lines (ptrdiff_t start_byte, ptrdiff_t end_byte)
 28628 {
 28629   ptrdiff_t ignored;
 28630   return display_count_lines (start_byte, end_byte, ZV, &ignored);
 28631 }
 28632 
 28633 /* Count up to COUNT lines starting from START_BYTE.  COUNT negative
 28634    means count lines back from START_BYTE.  But don't go beyond
 28635    LIMIT_BYTE.  Return the number of lines thus found (always
 28636    nonnegative).
 28637 
 28638    Set *BYTE_POS_PTR to the byte position where we stopped.  This is
 28639    either the position COUNT lines after/before START_BYTE, if we
 28640    found COUNT lines, or LIMIT_BYTE if we hit the limit before finding
 28641    COUNT lines.  */
 28642 
 28643 static ptrdiff_t
 28644 display_count_lines (ptrdiff_t start_byte,
 28645                      ptrdiff_t limit_byte, ptrdiff_t count,
 28646                      ptrdiff_t *byte_pos_ptr)
 28647 {
 28648   register unsigned char *cursor;
 28649   unsigned char *base;
 28650 
 28651   register ptrdiff_t ceiling;
 28652   register unsigned char *ceiling_addr;
 28653   ptrdiff_t orig_count = count;
 28654 
 28655   /* If we are not in selective display mode,
 28656      check only for newlines.  */
 28657   bool selective_display
 28658     = (!NILP (BVAR (current_buffer, selective_display))
 28659        && !FIXNUMP (BVAR (current_buffer, selective_display)));
 28660 
 28661   if (count > 0)
 28662     {
 28663       while (start_byte < limit_byte)
 28664         {
 28665           ceiling =  BUFFER_CEILING_OF (start_byte);
 28666           ceiling = min (limit_byte - 1, ceiling);
 28667           ceiling_addr = BYTE_POS_ADDR (ceiling) + 1;
 28668           base = (cursor = BYTE_POS_ADDR (start_byte));
 28669 
 28670           do
 28671             {
 28672               if (selective_display)
 28673                 {
 28674                   while (*cursor != '\n' && *cursor != 015
 28675                          && ++cursor != ceiling_addr)
 28676                     continue;
 28677                   if (cursor == ceiling_addr)
 28678                     break;
 28679                 }
 28680               else
 28681                 {
 28682                   cursor = memchr (cursor, '\n', ceiling_addr - cursor);
 28683                   if (! cursor)
 28684                     break;
 28685                 }
 28686 
 28687               cursor++;
 28688 
 28689               if (--count == 0)
 28690                 {
 28691                   start_byte += cursor - base;
 28692                   *byte_pos_ptr = start_byte;
 28693                   return orig_count;
 28694                 }
 28695             }
 28696           while (cursor < ceiling_addr);
 28697 
 28698           start_byte += ceiling_addr - base;
 28699         }
 28700     }
 28701   else
 28702     {
 28703       while (start_byte > limit_byte)
 28704         {
 28705           ceiling = BUFFER_FLOOR_OF (start_byte - 1);
 28706           ceiling = max (limit_byte, ceiling);
 28707           ceiling_addr = BYTE_POS_ADDR (ceiling);
 28708           base = (cursor = BYTE_POS_ADDR (start_byte - 1) + 1);
 28709           while (true)
 28710             {
 28711               if (selective_display)
 28712                 {
 28713                   while (--cursor >= ceiling_addr
 28714                          && *cursor != '\n' && *cursor != 015)
 28715                     continue;
 28716                   if (cursor < ceiling_addr)
 28717                     break;
 28718                 }
 28719               else
 28720                 {
 28721                   cursor = memrchr (ceiling_addr, '\n', cursor - ceiling_addr);
 28722                   if (! cursor)
 28723                     break;
 28724                 }
 28725 
 28726               if (++count == 0)
 28727                 {
 28728                   start_byte += cursor - base + 1;
 28729                   *byte_pos_ptr = start_byte;
 28730                   /* When scanning backwards, we should
 28731                      not count the newline posterior to which we stop.  */
 28732                   return - orig_count - 1;
 28733                 }
 28734             }
 28735           start_byte += ceiling_addr - base;
 28736         }
 28737     }
 28738 
 28739   *byte_pos_ptr = limit_byte;
 28740 
 28741   if (count < 0)
 28742     return - orig_count + count;
 28743   return orig_count - count;
 28744 
 28745 }
 28746 
 28747 
 28748 
 28749 /***********************************************************************
 28750                          Displaying strings
 28751  ***********************************************************************/
 28752 
 28753 /* Display a NUL-terminated string, starting with index START.
 28754 
 28755    If STRING is non-null, display that C string.  Otherwise, the Lisp
 28756    string LISP_STRING is displayed.  There's a case that STRING is
 28757    non-null and LISP_STRING is not nil.  It means STRING is a string
 28758    data of LISP_STRING.  In that case, we display LISP_STRING while
 28759    ignoring its text properties.
 28760 
 28761    If FACE_STRING is not nil, FACE_STRING_POS is a position in
 28762    FACE_STRING.  Display STRING or LISP_STRING with the face at
 28763    FACE_STRING_POS in FACE_STRING:
 28764 
 28765    Display the string in the environment given by IT, but use the
 28766    standard display table, temporarily.
 28767 
 28768    FIELD_WIDTH is the minimum number of output glyphs to produce.
 28769    If STRING has fewer characters than FIELD_WIDTH, pad to the right
 28770    with spaces.  If STRING has more characters, more than FIELD_WIDTH
 28771    glyphs will be produced.  FIELD_WIDTH <= 0 means don't pad.
 28772 
 28773    PRECISION is the maximum number of characters to output from
 28774    STRING.  PRECISION < 0  means don't truncate the string.
 28775 
 28776    This is roughly equivalent to printf format specifiers:
 28777 
 28778    FIELD_WIDTH  PRECISION       PRINTF
 28779    ----------------------------------------
 28780    -1           -1              %s
 28781    -1           10              %.10s
 28782    10           -1              %10s
 28783    20           10              %20.10s
 28784 
 28785    MULTIBYTE zero means do not display multibyte chars, > 0 means do
 28786    display them, and < 0 means obey the current buffer's value of
 28787    enable_multibyte_characters.
 28788 
 28789    Value is the number of columns displayed.  */
 28790 
 28791 static int
 28792 display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_string,
 28793                 ptrdiff_t face_string_pos, ptrdiff_t start, struct it *it,
 28794                 int field_width, int precision, int max_x, int multibyte)
 28795 {
 28796   int hpos_at_start = it->hpos;
 28797   int saved_face_id = it->face_id;
 28798   struct glyph_row *row = it->glyph_row;
 28799   ptrdiff_t it_charpos;
 28800 
 28801   /* Initialize the iterator IT for iteration over STRING beginning
 28802      with index START.  */
 28803   reseat_to_string (it, NILP (lisp_string) ? string : NULL, lisp_string,
 28804                     start, precision, field_width, multibyte);
 28805 
 28806   if (string && STRINGP (lisp_string))
 28807     /* LISP_STRING is the one returned by decode_mode_spec.  We should
 28808        ignore its text properties.  */
 28809     it->stop_charpos = it->end_charpos;
 28810 
 28811   /* If displaying STRING, set up the face of the iterator from
 28812      FACE_STRING, if that's given.  */
 28813   if (STRINGP (face_string))
 28814     {
 28815       ptrdiff_t endptr;
 28816       struct face *face;
 28817 
 28818       it->face_id
 28819         = face_at_string_position (it->w, face_string, face_string_pos,
 28820                                    0, &endptr, it->base_face_id, false, 0);
 28821       face = FACE_FROM_ID (it->f, it->face_id);
 28822       it->face_box_p = face->box != FACE_NO_BOX;
 28823 
 28824       /* If we have a display spec, but there's no Lisp string being
 28825          displayed, then check whether we've got one from the
 28826          :propertize being passed in and use that.  */
 28827       if (NILP (lisp_string))
 28828         {
 28829           Lisp_Object display = Fget_text_property (make_fixnum (0), Qdisplay,
 28830                                                     face_string);
 28831           if (!NILP (display))
 28832             {
 28833               Lisp_Object min_width = plist_get (display, Qmin_width);
 28834               if (!NILP (min_width))
 28835                 display_min_width (it, 0, face_string, min_width);
 28836             }
 28837         }
 28838     }
 28839 
 28840   /* Set max_x to the maximum allowed X position.  Don't let it go
 28841      beyond the right edge of the window.  */
 28842   if (max_x <= 0)
 28843     max_x = it->last_visible_x;
 28844   else
 28845     max_x = min (max_x, it->last_visible_x);
 28846 
 28847   /* Skip over display elements that are not visible because IT->w is
 28848      hscrolled.  */
 28849   if (it->current_x < it->first_visible_x)
 28850     move_it_in_display_line_to (it, 100000, it->first_visible_x,
 28851                                 MOVE_TO_POS | MOVE_TO_X);
 28852 
 28853   row->ascent = it->max_ascent;
 28854   row->height = it->max_ascent + it->max_descent;
 28855   row->phys_ascent = it->max_phys_ascent;
 28856   row->phys_height = it->max_phys_ascent + it->max_phys_descent;
 28857   row->extra_line_spacing = it->max_extra_line_spacing;
 28858 
 28859   if (STRINGP (it->string))
 28860     it_charpos = IT_STRING_CHARPOS (*it);
 28861   else
 28862     it_charpos = IT_CHARPOS (*it);
 28863 
 28864   /* This condition is for the case that we are called with current_x
 28865      past last_visible_x.  */
 28866   while (it->current_x < max_x)
 28867     {
 28868       int x_before, x, n_glyphs_before, i, nglyphs;
 28869 
 28870       /* Get the next display element.  */
 28871       if (!get_next_display_element (it))
 28872         break;
 28873 
 28874       /* Produce glyphs.  */
 28875       x_before = it->current_x;
 28876       n_glyphs_before = row->used[TEXT_AREA];
 28877       PRODUCE_GLYPHS (it);
 28878 
 28879       nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
 28880       i = 0;
 28881       x = x_before;
 28882       while (i < nglyphs)
 28883         {
 28884           struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
 28885 
 28886           if (it->line_wrap != TRUNCATE
 28887               && x + glyph->pixel_width > max_x)
 28888             {
 28889               /* End of continued line or max_x reached.  */
 28890               if (CHAR_GLYPH_PADDING_P (*glyph))
 28891                 {
 28892                   /* A wide character is unbreakable.  */
 28893                   if (row->reversed_p)
 28894                     unproduce_glyphs (it, row->used[TEXT_AREA]
 28895                                       - n_glyphs_before);
 28896                   row->used[TEXT_AREA] = n_glyphs_before;
 28897                   it->current_x = x_before;
 28898                 }
 28899               else
 28900                 {
 28901                   if (row->reversed_p)
 28902                     unproduce_glyphs (it, row->used[TEXT_AREA]
 28903                                       - (n_glyphs_before + i));
 28904                   row->used[TEXT_AREA] = n_glyphs_before + i;
 28905                   it->current_x = x;
 28906                 }
 28907               break;
 28908             }
 28909           else if (x + glyph->pixel_width >= it->first_visible_x)
 28910             {
 28911               /* Glyph is at least partially visible.  */
 28912               ++it->hpos;
 28913               if (x < it->first_visible_x)
 28914                 row->x = x - it->first_visible_x;
 28915             }
 28916           else
 28917             {
 28918               /* Glyph is off the left margin of the display area.
 28919                  Should not happen.  */
 28920               emacs_abort ();
 28921             }
 28922 
 28923           row->ascent = max (row->ascent, it->max_ascent);
 28924           row->height = max (row->height, it->max_ascent + it->max_descent);
 28925           row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
 28926           row->phys_height = max (row->phys_height,
 28927                                   it->max_phys_ascent + it->max_phys_descent);
 28928           row->extra_line_spacing = max (row->extra_line_spacing,
 28929                                          it->max_extra_line_spacing);
 28930           x += glyph->pixel_width;
 28931           ++i;
 28932         }
 28933 
 28934       /* Stop if max_x reached.  */
 28935       if (i < nglyphs)
 28936         break;
 28937 
 28938       /* Stop at line ends.  */
 28939       if (ITERATOR_AT_END_OF_LINE_P (it))
 28940         {
 28941           it->continuation_lines_width = 0;
 28942           break;
 28943         }
 28944 
 28945       set_iterator_to_next (it, true);
 28946       if (STRINGP (it->string))
 28947         it_charpos = IT_STRING_CHARPOS (*it);
 28948       else
 28949         it_charpos = IT_CHARPOS (*it);
 28950 
 28951       /* Stop if truncating at the right edge.  */
 28952       if (it->line_wrap == TRUNCATE
 28953           && it->current_x >= it->last_visible_x)
 28954         {
 28955           /* Add truncation mark, but don't do it if the line is
 28956              truncated at a padding space.  */
 28957           /* Need to do the below for the last string character as
 28958              well, since it could be a double-width character, in
 28959              which case the previous character ends before
 28960              last_visible_x.  Thus, comparison with <=, not <.  */
 28961           if (it_charpos <= it->string_nchars)
 28962             {
 28963               if (!FRAME_WINDOW_P (it->f))
 28964                 {
 28965                   int ii, n;
 28966 
 28967                   if (it->current_x > it->last_visible_x)
 28968                     {
 28969                       /* This flag is true if we are displaying mode
 28970                          line, false for header-line or tab-line.  */
 28971                       bool mode_line_p = false;
 28972 
 28973                       /* ROW->mode_line_p is true if we display mode
 28974                          line or header-line or tab-line.  */
 28975                       if (row->mode_line_p)
 28976                         {
 28977                           struct window *w = it->w;
 28978                           if (row == MATRIX_MODE_LINE_ROW (w->desired_matrix))
 28979                             mode_line_p = true;
 28980                         }
 28981                       if (!row->reversed_p)
 28982                         {
 28983                           for (ii = row->used[TEXT_AREA] - 1; ii > 0; --ii)
 28984                             if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][ii]))
 28985                               break;
 28986                         }
 28987                       else
 28988                         {
 28989                           for (ii = 0; ii < row->used[TEXT_AREA]; ii++)
 28990                             if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][ii]))
 28991                               break;
 28992                           unproduce_glyphs (it, ii + 1);
 28993                           ii = row->used[TEXT_AREA] - (ii + 1);
 28994                         }
 28995                       for (n = row->used[TEXT_AREA]; ii < n; ++ii)
 28996                         {
 28997                           row->used[TEXT_AREA] = ii;
 28998                           if (row->mode_line_p)
 28999                             pad_mode_line (it, mode_line_p);
 29000                           else
 29001                             produce_special_glyphs (it, IT_TRUNCATION);
 29002                         }
 29003                     }
 29004                   produce_special_glyphs (it, IT_TRUNCATION);
 29005                 }
 29006               row->truncated_on_right_p = true;
 29007             }
 29008           break;
 29009         }
 29010     }
 29011 
 29012   /* Maybe insert a truncation at the left.  */
 29013   if (it->first_visible_x
 29014       && it_charpos > 0)
 29015     {
 29016       if (!FRAME_WINDOW_P (it->f)
 29017           || (row->reversed_p
 29018               ? WINDOW_RIGHT_FRINGE_WIDTH (it->w)
 29019               : WINDOW_LEFT_FRINGE_WIDTH (it->w)) == 0)
 29020         insert_left_trunc_glyphs (it);
 29021       row->truncated_on_left_p = true;
 29022     }
 29023 
 29024   it->face_id = saved_face_id;
 29025 
 29026   /* Value is number of columns displayed.  */
 29027   return it->hpos - hpos_at_start;
 29028 }
 29029 
 29030 
 29031 
 29032 /* This is like a combination of memq and assq.  Return 1/2 if PROPVAL
 29033    appears as an element of LIST or as the car of an element of LIST.
 29034    If PROPVAL is a list, compare each element against LIST in that
 29035    way, and return 1/2 if any element of PROPVAL is found in LIST.
 29036    Otherwise return 0.  This function cannot quit.
 29037    The return value is 2 if the text is invisible but with an ellipsis
 29038    and 1 if it's invisible and without an ellipsis.  */
 29039 
 29040 int
 29041 invisible_prop (Lisp_Object propval, Lisp_Object list)
 29042 {
 29043   Lisp_Object tail, proptail;
 29044 
 29045   for (tail = list; CONSP (tail); tail = XCDR (tail))
 29046     {
 29047       register Lisp_Object tem;
 29048       tem = XCAR (tail);
 29049       if (EQ (propval, tem))
 29050         return 1;
 29051       if (CONSP (tem) && EQ (propval, XCAR (tem)))
 29052         return NILP (XCDR (tem)) ? 1 : 2;
 29053     }
 29054 
 29055   if (CONSP (propval))
 29056     {
 29057       for (proptail = propval; CONSP (proptail); proptail = XCDR (proptail))
 29058         {
 29059           Lisp_Object propelt;
 29060           propelt = XCAR (proptail);
 29061           for (tail = list; CONSP (tail); tail = XCDR (tail))
 29062             {
 29063               register Lisp_Object tem;
 29064               tem = XCAR (tail);
 29065               if (EQ (propelt, tem))
 29066                 return 1;
 29067               if (CONSP (tem) && EQ (propelt, XCAR (tem)))
 29068                 return NILP (XCDR (tem)) ? 1 : 2;
 29069             }
 29070         }
 29071     }
 29072 
 29073   return 0;
 29074 }
 29075 
 29076 DEFUN ("invisible-p", Finvisible_p, Sinvisible_p, 1, 1, 0,
 29077        doc: /* Non-nil if text properties at POS cause text there to be currently invisible.
 29078 POS should be a marker or a buffer position; the value of the `invisible'
 29079 property at that position in the current buffer is examined.
 29080 POS can also be the actual value of the `invisible' text or overlay
 29081 property of the text of interest, in which case the value itself is
 29082 examined.
 29083 
 29084 The non-nil value returned can be t for currently invisible text that is
 29085 entirely hidden on display, or some other non-nil, non-t value if the
 29086 text is replaced by an ellipsis.
 29087 
 29088 Note that whether text with `invisible' property is actually hidden on
 29089 display may depend on `buffer-invisibility-spec', which see.  */)
 29090   (Lisp_Object pos)
 29091 {
 29092   Lisp_Object prop
 29093     = (FIXNATP (pos) || MARKERP (pos)
 29094        ? Fget_char_property (pos, Qinvisible, Qnil)
 29095        : pos);
 29096   int invis = TEXT_PROP_MEANS_INVISIBLE (prop);
 29097   return (invis == 0 ? Qnil
 29098           : invis == 1 ? Qt
 29099           : make_fixnum (invis));
 29100 }
 29101 
 29102 /* Calculate a width or height in pixels from a specification using
 29103    the following elements:
 29104 
 29105    SPEC ::=
 29106      NUM      - a (fractional) multiple of the default font width/height
 29107      (NUM)    - specifies exactly NUM pixels
 29108      UNIT     - a fixed number of pixels, see below.
 29109      ELEMENT  - size of a display element in pixels, see below.
 29110      (NUM . SPEC) - equals NUM * SPEC
 29111      (+ SPEC SPEC ...)  - add pixel values
 29112      (- SPEC SPEC ...)  - subtract pixel values
 29113      (- SPEC)           - negate pixel value
 29114 
 29115    NUM ::=
 29116      INT or FLOAT   - a number constant
 29117      SYMBOL         - use symbol's (buffer local) variable binding.
 29118 
 29119    UNIT ::=
 29120      in       - pixels per inch  *)
 29121      mm       - pixels per 1/1000 meter  *)
 29122      cm       - pixels per 1/100 meter   *)
 29123      width    - width of current font in pixels.
 29124      height   - height of current font in pixels.
 29125 
 29126      *) using the ratio(s) defined in display-pixels-per-inch.
 29127 
 29128    ELEMENT ::=
 29129 
 29130      left-fringe          - left fringe width in pixels
 29131      right-fringe         - right fringe width in pixels
 29132 
 29133      left-margin          - left margin width in pixels
 29134      right-margin         - right margin width in pixels
 29135 
 29136      scroll-bar           - scroll-bar area width in pixels
 29137 
 29138    Examples:
 29139 
 29140    Pixels corresponding to 5 inches:
 29141      (5 . in)
 29142 
 29143    Total width of non-text areas on left side of window (if scroll-bar is on left):
 29144      '(space :width (+ left-fringe left-margin scroll-bar))
 29145 
 29146    Align to first text column (in header line):
 29147      '(space :align-to 0)
 29148 
 29149    Align to middle of text area minus half the width of variable `my-image'
 29150    containing a loaded image:
 29151      '(space :align-to (0.5 . (- text my-image)))
 29152 
 29153    Width of left margin minus width of 1 character in the default font:
 29154      '(space :width (- left-margin 1))
 29155 
 29156    Width of left margin minus width of 2 characters in the current font:
 29157      '(space :width (- left-margin (2 . width)))
 29158 
 29159    Center 1 character over left-margin (in header line):
 29160      '(space :align-to (+ left-margin (0.5 . left-margin) -0.5))
 29161 
 29162    Different ways to express width of left fringe plus left margin minus one pixel:
 29163      '(space :width (- (+ left-fringe left-margin) (1)))
 29164      '(space :width (+ left-fringe left-margin (- (1))))
 29165      '(space :width (+ left-fringe left-margin (-1)))
 29166 
 29167    If ALIGN_TO is NULL, returns the result in *RES.  If ALIGN_TO is
 29168    non-NULL, the value of *ALIGN_TO is a window-relative pixel
 29169    coordinate, and *RES is the additional pixel width from that point
 29170    till the end of the stretch glyph.
 29171 
 29172    WIDTH_P non-zero means take the width dimension or X coordinate of
 29173    the object specified by PROP, WIDTH_P zero means take the height
 29174    dimension or the Y coordinate.  (Therefore, if ALIGN_TO is
 29175    non-NULL, WIDTH_P should be non-zero.)
 29176 
 29177    FONT is the font of the face of the surrounding text.
 29178 
 29179    The return value is non-zero if width or height were successfully
 29180    calculated, i.e. if PROP is a valid spec.  */
 29181 
 29182 static bool
 29183 calc_pixel_width_or_height (double *res, struct it *it, Lisp_Object prop,
 29184                             struct font *font, bool width_p, int *align_to)
 29185 {
 29186   /* Don't adjust for line number if we didn't yet produce it for this
 29187      screen line.  This is for when this function is called from
 29188      move_it_in_display_line_to that was called by display_line to get
 29189      past the glyphs hscrolled off the left side of the window.  */
 29190   int lnum_pixel_width = it->line_number_produced_p ? it->lnum_pixel_width : 0;
 29191   double pixels;
 29192 
 29193 # define OK_PIXELS(val) (*res = (val), true)
 29194 # define OK_ALIGN_TO(val) (*align_to = (val), true)
 29195 
 29196   if (NILP (prop))
 29197     return OK_PIXELS (0);
 29198 
 29199   eassert (FRAME_LIVE_P (it->f));
 29200 
 29201   if (SYMBOLP (prop))
 29202     {
 29203       if (SCHARS (SYMBOL_NAME (prop)) == 2)
 29204         {
 29205           char *unit = SSDATA (SYMBOL_NAME (prop));
 29206 
 29207           /* The UNIT expression, e.g. as part of (NUM . UNIT).  */
 29208           if (unit[0] == 'i' && unit[1] == 'n')
 29209             pixels = 1.0;
 29210           else if (unit[0] == 'm' && unit[1] == 'm')
 29211             pixels = 25.4;
 29212           else if (unit[0] == 'c' && unit[1] == 'm')
 29213             pixels = 2.54;
 29214           else
 29215             pixels = 0;
 29216           if (pixels > 0)
 29217             {
 29218               double ppi = (width_p ? FRAME_RES_X (it->f)
 29219                             : FRAME_RES_Y (it->f));
 29220 
 29221               if (ppi > 0)
 29222                 return OK_PIXELS (ppi / pixels);
 29223               return false;
 29224             }
 29225         }
 29226 
 29227 #ifdef HAVE_WINDOW_SYSTEM
 29228       /* 'height': the height of FONT.  */
 29229       if (EQ (prop, Qheight))
 29230         return OK_PIXELS (font
 29231                           ? normal_char_height (font, -1)
 29232                           : FRAME_LINE_HEIGHT (it->f));
 29233       /* 'width': the width of FONT.  */
 29234       if (EQ (prop, Qwidth))
 29235         return OK_PIXELS (font
 29236                           ? FONT_WIDTH (font)
 29237                           : FRAME_COLUMN_WIDTH (it->f));
 29238 #else
 29239       if (EQ (prop, Qheight) || EQ (prop, Qwidth))
 29240         return OK_PIXELS (1);
 29241 #endif
 29242 
 29243       /* 'text': the width or height of the text area.  */
 29244       if (EQ (prop, Qtext))
 29245           return OK_PIXELS (width_p
 29246                             ? (window_box_width (it->w, TEXT_AREA)
 29247                                - lnum_pixel_width)
 29248                             : WINDOW_BOX_HEIGHT_NO_MODE_LINE (it->w));
 29249 
 29250       /* ':align_to'.  First time we compute the value, window
 29251          elements are interpreted as the position of the element's
 29252          left edge.  */
 29253       if (align_to && *align_to < 0)
 29254         {
 29255           *res = 0;
 29256           /* 'left': left edge of the text area.  */
 29257           if (EQ (prop, Qleft))
 29258             return OK_ALIGN_TO (window_box_left_offset (it->w, TEXT_AREA)
 29259                                 + lnum_pixel_width);
 29260           /* 'right': right edge of the text area.  */
 29261           if (EQ (prop, Qright))
 29262             return OK_ALIGN_TO (window_box_right_offset (it->w, TEXT_AREA));
 29263           /* 'center': the center of the text area.  */
 29264           if (EQ (prop, Qcenter))
 29265             return OK_ALIGN_TO (window_box_left_offset (it->w, TEXT_AREA)
 29266                                 + lnum_pixel_width
 29267                                 + window_box_width (it->w, TEXT_AREA) / 2);
 29268           /* 'left-fringe': left edge of the left fringe.  */
 29269           if (EQ (prop, Qleft_fringe))
 29270             return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
 29271                                 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (it->w)
 29272                                 : window_box_right_offset (it->w, LEFT_MARGIN_AREA));
 29273           /* 'right-fringe': left edge of the right fringe.  */
 29274           if (EQ (prop, Qright_fringe))
 29275             return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
 29276                                 ? window_box_right_offset (it->w, RIGHT_MARGIN_AREA)
 29277                                 : window_box_right_offset (it->w, TEXT_AREA));
 29278           /* 'left-margin': left edge of the left display margin.  */
 29279           if (EQ (prop, Qleft_margin))
 29280             return OK_ALIGN_TO (window_box_left_offset (it->w, LEFT_MARGIN_AREA));
 29281           /* 'right-margin': left edge of the right display margin.  */
 29282           if (EQ (prop, Qright_margin))
 29283             return OK_ALIGN_TO (window_box_left_offset (it->w, RIGHT_MARGIN_AREA));
 29284           /* 'scroll-bar': left edge of the vertical scroll bar.  */
 29285           if (EQ (prop, Qscroll_bar))
 29286             return OK_ALIGN_TO (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (it->w)
 29287                                 ? 0
 29288                                 : (window_box_right_offset (it->w, RIGHT_MARGIN_AREA)
 29289                                    + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
 29290                                       ? WINDOW_RIGHT_FRINGE_WIDTH (it->w)
 29291                                       : 0)));
 29292         }
 29293       else
 29294         {
 29295           /* Otherwise, the elements stand for their width.  */
 29296           if (EQ (prop, Qleft_fringe))
 29297             return OK_PIXELS (WINDOW_LEFT_FRINGE_WIDTH (it->w));
 29298           if (EQ (prop, Qright_fringe))
 29299             return OK_PIXELS (WINDOW_RIGHT_FRINGE_WIDTH (it->w));
 29300           if (EQ (prop, Qleft_margin))
 29301             return OK_PIXELS (WINDOW_LEFT_MARGIN_WIDTH (it->w));
 29302           if (EQ (prop, Qright_margin))
 29303             return OK_PIXELS (WINDOW_RIGHT_MARGIN_WIDTH (it->w));
 29304           if (EQ (prop, Qscroll_bar))
 29305             return OK_PIXELS (WINDOW_SCROLL_BAR_AREA_WIDTH (it->w));
 29306         }
 29307 
 29308       prop = buffer_local_value (prop, it->w->contents);
 29309       if (BASE_EQ (prop, Qunbound))
 29310         prop = Qnil;
 29311     }
 29312 
 29313   if (NUMBERP (prop))
 29314     {
 29315       int base_unit = (width_p
 29316                        ? FRAME_COLUMN_WIDTH (it->f)
 29317                        : FRAME_LINE_HEIGHT (it->f));
 29318       if (width_p && align_to && *align_to < 0)
 29319         return OK_PIXELS (XFLOATINT (prop) * base_unit + lnum_pixel_width);
 29320       return OK_PIXELS (XFLOATINT (prop) * base_unit);
 29321     }
 29322 
 29323   if (CONSP (prop))
 29324     {
 29325       Lisp_Object car = XCAR (prop);
 29326       Lisp_Object cdr = XCDR (prop);
 29327 
 29328       if (SYMBOLP (car))
 29329         {
 29330 #ifdef HAVE_WINDOW_SYSTEM
 29331           /* '(image PROPS...)': width or height of the specified image.  */
 29332           if (FRAME_WINDOW_P (it->f)
 29333               && valid_image_p (prop))
 29334             {
 29335               ptrdiff_t id = lookup_image (it->f, prop, it->face_id);
 29336               struct image *img = IMAGE_FROM_ID (it->f, id);
 29337 
 29338               return OK_PIXELS (width_p ? img->width : img->height);
 29339             }
 29340           /* '(xwidget PROPS...)': dimensions of the specified xwidget.  */
 29341           if (FRAME_WINDOW_P (it->f) && valid_xwidget_spec_p (prop))
 29342             {
 29343               /* TODO: Don't return dummy size.  */
 29344               return OK_PIXELS (100);
 29345             }
 29346 #endif
 29347           /* '(+ EXPR...)' or '(- EXPR...)' add or subtract
 29348              recursively calculated values.  */
 29349           if (EQ (car, Qplus) || EQ (car, Qminus))
 29350             {
 29351               bool first = true;
 29352               double px;
 29353 
 29354               pixels = 0;
 29355               while (CONSP (cdr))
 29356                 {
 29357                   if (!calc_pixel_width_or_height (&px, it, XCAR (cdr),
 29358                                                    font, width_p, align_to))
 29359                     return false;
 29360                   if (first)
 29361                     pixels = (EQ (car, Qplus) ? px : -px), first = false;
 29362                   else
 29363                     pixels += px;
 29364                   cdr = XCDR (cdr);
 29365                 }
 29366               if (EQ (car, Qminus))
 29367                 pixels = -pixels;
 29368               return OK_PIXELS (pixels);
 29369             }
 29370 
 29371           car = buffer_local_value (car, it->w->contents);
 29372           if (BASE_EQ (car, Qunbound))
 29373             car = Qnil;
 29374         }
 29375 
 29376       /* '(NUM)': absolute number of pixels.  */
 29377       if (NUMBERP (car))
 29378         {
 29379           double fact;
 29380           int offset =
 29381             width_p && align_to && *align_to < 0 ? lnum_pixel_width : 0;
 29382           pixels = XFLOATINT (car);
 29383           if (NILP (cdr))
 29384             return OK_PIXELS (pixels + offset);
 29385           if (calc_pixel_width_or_height (&fact, it, cdr,
 29386                                           font, width_p, align_to))
 29387             return OK_PIXELS (pixels * fact + offset);
 29388           return false;
 29389         }
 29390 
 29391       return false;
 29392     }
 29393 
 29394   return false;
 29395 }
 29396 
 29397 void
 29398 get_font_ascent_descent (struct font *font, int *ascent, int *descent)
 29399 {
 29400 #ifdef HAVE_WINDOW_SYSTEM
 29401   normal_char_ascent_descent (font, -1, ascent, descent);
 29402 #else
 29403   *ascent = 1;
 29404   *descent = 0;
 29405 #endif
 29406 }
 29407 
 29408 
 29409 /***********************************************************************
 29410                              Glyph Display
 29411  ***********************************************************************/
 29412 
 29413 #ifdef HAVE_WINDOW_SYSTEM
 29414 
 29415 #ifdef GLYPH_DEBUG
 29416 
 29417 extern void dump_glyph_string (struct glyph_string *) EXTERNALLY_VISIBLE;
 29418 void
 29419 dump_glyph_string (struct glyph_string *s)
 29420 {
 29421   fputs ("glyph string\n", stderr);
 29422   fprintf (stderr, "  x, y, w, h = %d, %d, %d, %d\n",
 29423            s->x, s->y, s->width, s->height);
 29424   fprintf (stderr, "  ybase = %d\n", s->ybase);
 29425   fprintf (stderr, "  hl = %u\n", s->hl);
 29426   fprintf (stderr, "  left overhang = %d, right = %d\n",
 29427            s->left_overhang, s->right_overhang);
 29428   fprintf (stderr, "  nchars = %d\n", s->nchars);
 29429   fprintf (stderr, "  extends to end of line = %d\n",
 29430            s->extends_to_end_of_line_p);
 29431   fprintf (stderr, "  font height = %d\n", FONT_HEIGHT (s->font));
 29432   fprintf (stderr, "  bg width = %d\n", s->background_width);
 29433 }
 29434 
 29435 #endif /* GLYPH_DEBUG */
 29436 
 29437 /* Initialize glyph string S.  CHAR2B is a suitably allocated vector
 29438    of 2-byte unsigned integers for S; it can't be allocated in
 29439    init_glyph_string because it must be allocated via `alloca'.  W
 29440    is the window on which S is drawn.  ROW and AREA are the glyph row
 29441    and area within the row from which S is constructed.  START is the
 29442    index of the first glyph structure covered by S.  HL is a
 29443    face-override for drawing S.  */
 29444 
 29445 #ifdef HAVE_NTGUI
 29446 /* We set inhibit-quit here due to paranoia: get_frame_dc acquires the
 29447    critical section, and we cannot QUIT while we hold the critical
 29448    section.  If any of the code run by callers of ALLOCATE_HDC happens
 29449    to call Lisp (might be possible due to all the hooks lying around),
 29450    we must prevent it from quitting.  */
 29451 # define ALLOCATE_HDC(hdc, f)                   \
 29452   Lisp_Object prev_quit = Vinhibit_quit;        \
 29453   Vinhibit_quit = Qt;                           \
 29454   HDC hdc = get_frame_dc ((f))
 29455 # define RELEASE_HDC(hdc, f)                    \
 29456   release_frame_dc ((f), (hdc));                \
 29457   Vinhibit_quit = prev_quit
 29458 #else
 29459 # define ALLOCATE_HDC(hdc, f)
 29460 # define RELEASE_HDC(hdc, f)
 29461 #endif
 29462 
 29463 static void
 29464 init_glyph_string (struct glyph_string *s,
 29465 #ifdef HAVE_NTGUI
 29466                    HDC hdc,
 29467 #endif
 29468                    unsigned *char2b, struct window *w, struct glyph_row *row,
 29469                    enum glyph_row_area area, int start, enum draw_glyphs_face hl)
 29470 {
 29471   memset (s, 0, sizeof *s);
 29472   s->w = w;
 29473   s->f = XFRAME (w->frame);
 29474 #ifdef HAVE_NTGUI
 29475   s->hdc = hdc;
 29476 #endif
 29477   s->char2b = char2b;
 29478   s->hl = hl;
 29479   s->row = row;
 29480   s->area = area;
 29481   s->first_glyph = row->glyphs[area] + start;
 29482   s->height = row->height;
 29483   s->y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
 29484   s->ybase = s->y + row->ascent;
 29485 }
 29486 
 29487 
 29488 /* Append the list of glyph strings with head H and tail T to the list
 29489    with head *HEAD and tail *TAIL.  Set *HEAD and *TAIL to the result.  */
 29490 
 29491 static void
 29492 append_glyph_string_lists (struct glyph_string **head, struct glyph_string **tail,
 29493                            struct glyph_string *h, struct glyph_string *t)
 29494 {
 29495   if (h)
 29496     {
 29497       if (*head)
 29498         (*tail)->next = h;
 29499       else
 29500         *head = h;
 29501       h->prev = *tail;
 29502       *tail = t;
 29503     }
 29504 }
 29505 
 29506 
 29507 /* Prepend the list of glyph strings with head H and tail T to the
 29508    list with head *HEAD and tail *TAIL.  Set *HEAD and *TAIL to the
 29509    result.  */
 29510 
 29511 static void
 29512 prepend_glyph_string_lists (struct glyph_string **head, struct glyph_string **tail,
 29513                             struct glyph_string *h, struct glyph_string *t)
 29514 {
 29515   if (h)
 29516     {
 29517       if (*head)
 29518         (*head)->prev = t;
 29519       else
 29520         *tail = t;
 29521       t->next = *head;
 29522       *head = h;
 29523     }
 29524 }
 29525 
 29526 
 29527 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
 29528    Set *HEAD and *TAIL to the resulting list.  */
 29529 
 29530 static void
 29531 append_glyph_string (struct glyph_string **head, struct glyph_string **tail,
 29532                      struct glyph_string *s)
 29533 {
 29534   s->next = s->prev = NULL;
 29535   append_glyph_string_lists (head, tail, s, s);
 29536 }
 29537 
 29538 
 29539 /* Get face and two-byte form of character C in face FACE_ID on frame F.
 29540    The encoding of C is returned in *CHAR2B.  DISPLAY_P means
 29541    make sure that X resources for the face returned are allocated.
 29542    Value is a pointer to a realized face that is ready for display if
 29543    DISPLAY_P.  */
 29544 
 29545 static struct face *
 29546 get_char_face_and_encoding (struct frame *f, int c, int face_id,
 29547                             unsigned *char2b, bool display_p)
 29548 {
 29549   struct face *face = FACE_FROM_ID (f, face_id);
 29550   unsigned code = 0;
 29551 
 29552   if (face->font)
 29553     {
 29554       code = face->font->driver->encode_char (face->font, c);
 29555 
 29556       if (code == FONT_INVALID_CODE)
 29557         code = 0;
 29558     }
 29559   /* Ensure that the code is only 2 bytes wide.  */
 29560   *char2b = code & 0xFFFF;
 29561 
 29562   /* Make sure X resources of the face are allocated.  */
 29563 #ifdef HAVE_X_WINDOWS
 29564   if (display_p)
 29565 #endif
 29566     {
 29567       eassert (face != NULL);
 29568       prepare_face_for_display (f, face);
 29569     }
 29570 
 29571   return face;
 29572 }
 29573 
 29574 
 29575 /* Get face and two-byte form of character glyph GLYPH on frame F.
 29576    The encoding of GLYPH->u.ch is returned in *CHAR2B.  Value is
 29577    a pointer to a realized face that is ready for display.  */
 29578 
 29579 static struct face *
 29580 get_glyph_face_and_encoding (struct frame *f, struct glyph *glyph,
 29581                              unsigned *char2b)
 29582 {
 29583   struct face *face;
 29584   unsigned code = 0;
 29585 
 29586   eassert (glyph->type == CHAR_GLYPH);
 29587   face = FACE_FROM_ID (f, glyph->face_id);
 29588 
 29589   /* Make sure X resources of the face are allocated.  */
 29590   prepare_face_for_display (f, face);
 29591 
 29592   if (face->font)
 29593     {
 29594       if (CHAR_BYTE8_P (glyph->u.ch))
 29595         code = CHAR_TO_BYTE8 (glyph->u.ch);
 29596       else
 29597         code = face->font->driver->encode_char (face->font, glyph->u.ch);
 29598 
 29599       if (code == FONT_INVALID_CODE)
 29600         code = 0;
 29601     }
 29602 
 29603   /* Ensure that the code is only 2 bytes wide.  */
 29604   *char2b = code & 0xFFFF;
 29605   return face;
 29606 }
 29607 
 29608 
 29609 /* Get glyph code of character C in FONT in the two-byte form CHAR2B.
 29610    Return true iff FONT has a glyph for C.  */
 29611 
 29612 static bool
 29613 get_char_glyph_code (int c, struct font *font, unsigned *char2b)
 29614 {
 29615   unsigned code;
 29616 
 29617   if (CHAR_BYTE8_P (c))
 29618     code = CHAR_TO_BYTE8 (c);
 29619   else
 29620     code = font->driver->encode_char (font, c);
 29621 
 29622   if (code == FONT_INVALID_CODE)
 29623     return false;
 29624 
 29625   /* Ensure that the code is only 2 bytes wide.  */
 29626   *char2b = code & 0xFFFF;
 29627   return true;
 29628 }
 29629 
 29630 
 29631 /* Fill glyph string S with composition components specified by S->cmp.
 29632 
 29633    BASE_FACE is the base face of the composition.
 29634    S->cmp_from is the index of the first component for S.
 29635 
 29636    OVERLAPS non-zero means S should draw the foreground only, and use
 29637    its physical height for clipping.  See also draw_glyphs.
 29638 
 29639    Value is the index of a component not in S.  */
 29640 
 29641 static int
 29642 fill_composite_glyph_string (struct glyph_string *s, struct face *base_face,
 29643                              int overlaps)
 29644 {
 29645   int i;
 29646   /* For all glyphs of this composition, starting at the offset
 29647      S->cmp_from, until we reach the end of the definition or encounter a
 29648      glyph that requires the different face, add it to S.  */
 29649   struct face *face;
 29650 
 29651   eassert (s);
 29652 
 29653   s->for_overlaps = overlaps;
 29654   s->face = NULL;
 29655   s->font = NULL;
 29656   for (i = s->cmp_from; i < s->cmp->glyph_len; i++)
 29657     {
 29658       int c = COMPOSITION_GLYPH (s->cmp, i);
 29659 
 29660       /* TAB in a composition means display glyphs with padding space
 29661          on the left or right.  */
 29662       if (c != '\t')
 29663         {
 29664           int face_id = FACE_FOR_CHAR (s->f, base_face->ascii_face, c,
 29665                                        -1, Qnil);
 29666 
 29667           face = get_char_face_and_encoding (s->f, c, face_id,
 29668                                              s->char2b + i, true);
 29669           if (face)
 29670             {
 29671               if (! s->face)
 29672                 {
 29673                   s->face = face;
 29674                   s->font = s->face->font;
 29675                 }
 29676               else if (s->face != face)
 29677                 break;
 29678             }
 29679         }
 29680       ++s->nchars;
 29681     }
 29682   s->cmp_to = i;
 29683 
 29684   if (s->face == NULL)
 29685     {
 29686       s->face = base_face->ascii_face;
 29687       s->font = s->face->font;
 29688     }
 29689 
 29690   if (s->hl == DRAW_MOUSE_FACE
 29691       || (s->hl == DRAW_CURSOR
 29692           && MATRIX_ROW (s->w->current_matrix,
 29693                          s->w->phys_cursor.vpos)->mouse_face_p
 29694           && cursor_in_mouse_face_p (s->w)))
 29695     {
 29696       int c = COMPOSITION_GLYPH (s->cmp, 0);
 29697       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29698       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29699       if (!s->face)
 29700         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29701 
 29702       s->face = FACE_FROM_ID (s->f, FACE_FOR_CHAR (s->f, s->face, c, -1, Qnil));
 29703       prepare_face_for_display (s->f, s->face);
 29704     }
 29705 
 29706   /* All glyph strings for the same composition has the same width,
 29707      i.e. the width set for the first component of the composition.  */
 29708   s->width = s->first_glyph->pixel_width;
 29709 
 29710   /* If the specified font could not be loaded, use the frame's
 29711      default font, but record the fact that we couldn't load it in
 29712      the glyph string so that we can draw rectangles for the
 29713      characters of the glyph string.  */
 29714   if (s->font == NULL)
 29715     {
 29716       s->font_not_found_p = true;
 29717       s->font = FRAME_FONT (s->f);
 29718     }
 29719 
 29720   /* Adjust base line for subscript/superscript text.  */
 29721   s->ybase += s->first_glyph->voffset;
 29722 
 29723   return s->cmp_to;
 29724 }
 29725 
 29726 static int
 29727 fill_gstring_glyph_string (struct glyph_string *s, int face_id,
 29728                            int start, int end, int overlaps)
 29729 {
 29730   struct glyph *glyph, *last;
 29731   int voffset;
 29732   Lisp_Object lgstring;
 29733   int i;
 29734   bool glyph_not_available_p;
 29735 
 29736   s->for_overlaps = overlaps;
 29737   glyph = s->row->glyphs[s->area] + start;
 29738   last = s->row->glyphs[s->area] + end;
 29739   voffset = glyph->voffset;
 29740   glyph_not_available_p = glyph->glyph_not_available_p;
 29741   s->cmp_id = glyph->u.cmp.id;
 29742   s->cmp_from = glyph->slice.cmp.from;
 29743   s->cmp_to = glyph->slice.cmp.to + 1;
 29744   if (s->hl == DRAW_MOUSE_FACE
 29745       || (s->hl == DRAW_CURSOR
 29746           && MATRIX_ROW (s->w->current_matrix,
 29747                          s->w->phys_cursor.vpos)->mouse_face_p
 29748           && cursor_in_mouse_face_p (s->w)))
 29749     {
 29750       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29751       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29752       if (!s->face)
 29753         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29754       prepare_face_for_display (s->f, s->face);
 29755     }
 29756   else
 29757     s->face = FACE_FROM_ID (s->f, face_id);
 29758   lgstring = composition_gstring_from_id (s->cmp_id);
 29759   s->font = XFONT_OBJECT (LGSTRING_FONT (lgstring));
 29760   /* The width of a composition glyph string is the sum of the
 29761      composition's glyph widths.  */
 29762   s->width = s->first_glyph->pixel_width;
 29763   glyph++;
 29764   while (glyph < last
 29765          && glyph->u.cmp.automatic
 29766          && glyph->u.cmp.id == s->cmp_id
 29767          && glyph->face_id == face_id
 29768          && s->cmp_to == glyph->slice.cmp.from
 29769          && glyph->glyph_not_available_p == glyph_not_available_p)
 29770     {
 29771       s->width += glyph->pixel_width;
 29772       s->cmp_to = (glyph++)->slice.cmp.to + 1;
 29773     }
 29774 
 29775   for (i = s->cmp_from; i < s->cmp_to; i++)
 29776     {
 29777       Lisp_Object lglyph = LGSTRING_GLYPH (lgstring, i);
 29778       unsigned code = LGLYPH_CODE (lglyph);
 29779 
 29780       /* Ensure that the code is only 2 bytes wide.  */
 29781       s->char2b[i] = code & 0xFFFF;
 29782     }
 29783 
 29784   /* If the specified font could not be loaded, record that fact in
 29785      S->font_not_found_p so that we can draw rectangles for the
 29786      characters of the glyph string.  */
 29787   if (glyph_not_available_p)
 29788     s->font_not_found_p = true;
 29789 
 29790   /* Adjust base line for subscript/superscript text.  */
 29791   s->ybase += voffset;
 29792 
 29793   return glyph - s->row->glyphs[s->area];
 29794 }
 29795 
 29796 
 29797 /* Fill glyph string S from a sequence glyphs for glyphless characters.
 29798    See the comment of fill_glyph_string for arguments.
 29799    Value is the index of the first glyph not in S.  */
 29800 
 29801 
 29802 static int
 29803 fill_glyphless_glyph_string (struct glyph_string *s, int face_id,
 29804                              int start, int end, int overlaps)
 29805 {
 29806   struct glyph *glyph, *last;
 29807   int voffset;
 29808 
 29809   eassert (s->first_glyph->type == GLYPHLESS_GLYPH);
 29810   s->for_overlaps = overlaps;
 29811   glyph = s->row->glyphs[s->area] + start;
 29812   last = s->row->glyphs[s->area] + end;
 29813   voffset = glyph->voffset;
 29814   s->face = FACE_FROM_ID (s->f, face_id);
 29815   s->font = s->face->font ? s->face->font : FRAME_FONT (s->f);
 29816   if (s->hl == DRAW_MOUSE_FACE
 29817       || (s->hl == DRAW_CURSOR
 29818           && MATRIX_ROW (s->w->current_matrix,
 29819                          s->w->phys_cursor.vpos)->mouse_face_p
 29820           && cursor_in_mouse_face_p (s->w)))
 29821     {
 29822       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29823       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29824       if (!s->face)
 29825         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29826       prepare_face_for_display (s->f, s->face);
 29827     }
 29828   s->nchars = 1;
 29829   s->width = glyph->pixel_width;
 29830   glyph++;
 29831   while (glyph < last
 29832          && glyph->type == GLYPHLESS_GLYPH
 29833          && glyph->voffset == voffset
 29834          && glyph->face_id == face_id)
 29835     {
 29836       s->nchars++;
 29837       s->width += glyph->pixel_width;
 29838       glyph++;
 29839     }
 29840   s->ybase += voffset;
 29841   return glyph - s->row->glyphs[s->area];
 29842 }
 29843 
 29844 
 29845 /* Fill glyph string S from a sequence of character glyphs.
 29846 
 29847    FACE_ID is the face id of the string.  START is the index of the
 29848    first glyph to consider, END is the index of the last + 1.
 29849    OVERLAPS non-zero means S should draw the foreground only, and use
 29850    its physical height for clipping.  See also draw_glyphs.
 29851 
 29852    Value is the index of the first glyph not in S.  */
 29853 
 29854 static int
 29855 fill_glyph_string (struct glyph_string *s, int face_id,
 29856                    int start, int end, int overlaps)
 29857 {
 29858   struct glyph *glyph, *last;
 29859   int voffset;
 29860   bool glyph_not_available_p;
 29861 
 29862   eassert (s->f == XFRAME (s->w->frame));
 29863   eassert (s->nchars == 0);
 29864   eassert (start >= 0 && end > start);
 29865 
 29866   s->for_overlaps = overlaps;
 29867   glyph = s->row->glyphs[s->area] + start;
 29868   last = s->row->glyphs[s->area] + end;
 29869   voffset = glyph->voffset;
 29870   s->padding_p = glyph->padding_p;
 29871   glyph_not_available_p = glyph->glyph_not_available_p;
 29872 
 29873   while (glyph < last
 29874          && glyph->type == CHAR_GLYPH
 29875          && glyph->voffset == voffset
 29876          /* Same face id implies same font, nowadays.  */
 29877          && glyph->face_id == face_id
 29878          && glyph->glyph_not_available_p == glyph_not_available_p)
 29879     {
 29880       s->face = get_glyph_face_and_encoding (s->f, glyph,
 29881                                              s->char2b + s->nchars);
 29882       ++s->nchars;
 29883       eassert (s->nchars <= end - start);
 29884       s->width += glyph->pixel_width;
 29885       if (glyph++->padding_p != s->padding_p)
 29886         break;
 29887     }
 29888 
 29889   s->font = s->face->font;
 29890 
 29891   if (s->hl == DRAW_MOUSE_FACE
 29892       || (s->hl == DRAW_CURSOR
 29893           && MATRIX_ROW (s->w->current_matrix,
 29894                          s->w->phys_cursor.vpos)->mouse_face_p
 29895           && cursor_in_mouse_face_p (s->w)))
 29896     {
 29897       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29898       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29899       if (!s->face)
 29900         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29901       s->face
 29902         = FACE_FROM_ID (s->f, FACE_FOR_CHAR (s->f, s->face,
 29903                                              s->first_glyph->u.ch, -1, Qnil));
 29904       prepare_face_for_display (s->f, s->face);
 29905     }
 29906 
 29907   /* If the specified font could not be loaded, use the frame's font,
 29908      but record the fact that we couldn't load it in
 29909      S->font_not_found_p so that we can draw rectangles for the
 29910      characters of the glyph string.  */
 29911   if (s->font == NULL || glyph_not_available_p)
 29912     {
 29913       s->font_not_found_p = true;
 29914       s->font = FRAME_FONT (s->f);
 29915     }
 29916 
 29917   /* Adjust base line for subscript/superscript text.  */
 29918   s->ybase += voffset;
 29919 
 29920   eassert (s->face && s->face->gc);
 29921   return glyph - s->row->glyphs[s->area];
 29922 }
 29923 
 29924 
 29925 /* Fill glyph string S from image glyph S->first_glyph.  */
 29926 
 29927 static void
 29928 fill_image_glyph_string (struct glyph_string *s)
 29929 {
 29930   eassert (s->first_glyph->type == IMAGE_GLYPH);
 29931   s->img = IMAGE_FROM_ID (s->f, s->first_glyph->u.img_id);
 29932   eassert (s->img);
 29933   s->slice = s->first_glyph->slice.img;
 29934   s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
 29935   s->font = s->face->font;
 29936   if (s->hl == DRAW_MOUSE_FACE
 29937       || (s->hl == DRAW_CURSOR
 29938           && MATRIX_ROW (s->w->current_matrix,
 29939                          s->w->phys_cursor.vpos)->mouse_face_p
 29940           && cursor_in_mouse_face_p (s->w)))
 29941     {
 29942       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29943       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29944       if (!s->face)
 29945         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29946       prepare_face_for_display (s->f, s->face);
 29947     }
 29948   s->width = s->first_glyph->pixel_width;
 29949 
 29950   /* Adjust base line for subscript/superscript text.  */
 29951   s->ybase += s->first_glyph->voffset;
 29952 }
 29953 
 29954 
 29955 #ifdef HAVE_XWIDGETS
 29956 static void
 29957 fill_xwidget_glyph_string (struct glyph_string *s)
 29958 {
 29959   eassert (s->first_glyph->type == XWIDGET_GLYPH);
 29960   s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
 29961   s->font = s->face->font;
 29962   if (s->hl == DRAW_MOUSE_FACE
 29963       || (s->hl == DRAW_CURSOR
 29964           && MATRIX_ROW (s->w->current_matrix,
 29965                          s->w->phys_cursor.vpos)->mouse_face_p
 29966           && cursor_in_mouse_face_p (s->w)))
 29967     {
 29968       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29969       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29970       if (!s->face)
 29971         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29972       prepare_face_for_display (s->f, s->face);
 29973     }
 29974   s->width = s->first_glyph->pixel_width;
 29975   s->ybase += s->first_glyph->voffset;
 29976   s->xwidget = xwidget_from_id (s->first_glyph->u.xwidget);
 29977 }
 29978 #endif
 29979 /* Fill glyph string S from a sequence of stretch glyphs.
 29980 
 29981    START is the index of the first glyph to consider,
 29982    END is the index of the last + 1.
 29983 
 29984    Value is the index of the first glyph not in S.  */
 29985 
 29986 static int
 29987 fill_stretch_glyph_string (struct glyph_string *s, int start, int end)
 29988 {
 29989   struct glyph *glyph, *last;
 29990   int voffset, face_id;
 29991 
 29992   eassert (s->first_glyph->type == STRETCH_GLYPH);
 29993 
 29994   glyph = s->row->glyphs[s->area] + start;
 29995   last = s->row->glyphs[s->area] + end;
 29996   face_id = glyph->face_id;
 29997   s->face = FACE_FROM_ID (s->f, face_id);
 29998   s->font = s->face->font;
 29999   if (s->hl == DRAW_MOUSE_FACE
 30000       || (s->hl == DRAW_CURSOR
 30001           && MATRIX_ROW (s->w->current_matrix,
 30002                          s->w->phys_cursor.vpos)->mouse_face_p
 30003           && cursor_in_mouse_face_p (s->w)))
 30004     {
 30005       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 30006       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 30007       if (!s->face)
 30008         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 30009       prepare_face_for_display (s->f, s->face);
 30010     }
 30011   s->width = glyph->pixel_width;
 30012   s->nchars = 1;
 30013   voffset = glyph->voffset;
 30014 
 30015   for (++glyph;
 30016        (glyph < last
 30017         && glyph->type == STRETCH_GLYPH
 30018         && glyph->voffset == voffset
 30019         && glyph->face_id == face_id);
 30020        ++glyph)
 30021     s->width += glyph->pixel_width;
 30022 
 30023   /* Adjust base line for subscript/superscript text.  */
 30024   s->ybase += voffset;
 30025 
 30026   /* The case that face->gc == 0 is handled when drawing the glyph
 30027      string by calling prepare_face_for_display.  */
 30028   eassert (s->face);
 30029   return glyph - s->row->glyphs[s->area];
 30030 }
 30031 
 30032 static struct font_metrics *
 30033 get_per_char_metric (struct font *font, const unsigned *char2b)
 30034 {
 30035   static struct font_metrics metrics;
 30036 
 30037   if (! font)
 30038     return NULL;
 30039   if (*char2b == FONT_INVALID_CODE)
 30040     return NULL;
 30041 
 30042   font->driver->text_extents (font, char2b, 1, &metrics);
 30043   return &metrics;
 30044 }
 30045 
 30046 /* A subroutine that computes "normal" values of ASCENT and DESCENT
 30047    for FONT.  Values are taken from font-global ones, except for fonts
 30048    that claim preposterously large values, but whose glyphs actually
 30049    have reasonable dimensions.  C is the character to use for metrics
 30050    if the font-global values are too large; if C is negative, the
 30051    function selects a default character.  */
 30052 static void
 30053 normal_char_ascent_descent (struct font *font, int c, int *ascent, int *descent)
 30054 {
 30055   *ascent = FONT_BASE (font);
 30056   *descent = FONT_DESCENT (font);
 30057 
 30058   if (FONT_TOO_HIGH (font))
 30059     {
 30060       unsigned char2b;
 30061 
 30062       /* Get metrics of C, defaulting to a reasonably sized ASCII
 30063          character.  */
 30064       if (get_char_glyph_code (c >= 0 ? c : '{', font, &char2b))
 30065         {
 30066           struct font_metrics *pcm = get_per_char_metric (font, &char2b);
 30067           eassume (pcm);
 30068 
 30069           if (!(pcm->width == 0 && pcm->rbearing == 0 && pcm->lbearing == 0))
 30070             {
 30071               /* We add 1 pixel to character dimensions as heuristics
 30072                  that produces nicer display, e.g. when the face has
 30073                  the box attribute.  */
 30074               *ascent = pcm->ascent + 1;
 30075               *descent = pcm->descent + 1;
 30076             }
 30077         }
 30078     }
 30079 }
 30080 
 30081 /* A subroutine that computes a reasonable "normal character height"
 30082    for fonts that claim preposterously large vertical dimensions, but
 30083    whose glyphs are actually reasonably sized.  C is the character
 30084    whose metrics to use for those fonts, or -1 for default
 30085    character.  */
 30086 static int
 30087 normal_char_height (struct font *font, int c)
 30088 {
 30089   int ascent, descent;
 30090 
 30091   normal_char_ascent_descent (font, c, &ascent, &descent);
 30092 
 30093   return ascent + descent;
 30094 }
 30095 
 30096 /* EXPORT for RIF:
 30097    Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
 30098    frame F.  Overhangs of glyphs other than type CHAR_GLYPH are
 30099    assumed to be zero.  */
 30100 
 30101 void
 30102 gui_get_glyph_overhangs (struct glyph *glyph, struct frame *f, int *left, int *right)
 30103 {
 30104   *left = *right = 0;
 30105 
 30106   if (glyph->type == CHAR_GLYPH)
 30107     {
 30108       unsigned char2b;
 30109       struct face *face = get_glyph_face_and_encoding (f, glyph, &char2b);
 30110       if (face->font)
 30111         {
 30112           struct font_metrics *pcm = get_per_char_metric (face->font, &char2b);
 30113           if (pcm)
 30114             {
 30115               if (pcm->rbearing > pcm->width)
 30116                 *right = pcm->rbearing - pcm->width;
 30117               if (pcm->lbearing < 0)
 30118                 *left = -pcm->lbearing;
 30119             }
 30120         }
 30121     }
 30122   else if (glyph->type == COMPOSITE_GLYPH)
 30123     {
 30124       if (! glyph->u.cmp.automatic)
 30125         {
 30126           struct composition *cmp = composition_table[glyph->u.cmp.id];
 30127 
 30128           if (cmp->rbearing > cmp->pixel_width)
 30129             *right = cmp->rbearing - cmp->pixel_width;
 30130           if (cmp->lbearing < 0)
 30131             *left = - cmp->lbearing;
 30132         }
 30133       else
 30134         {
 30135           Lisp_Object gstring = composition_gstring_from_id (glyph->u.cmp.id);
 30136           struct font_metrics metrics;
 30137 
 30138           composition_gstring_width (gstring, glyph->slice.cmp.from,
 30139                                      glyph->slice.cmp.to + 1, &metrics);
 30140           if (metrics.rbearing > metrics.width)
 30141             *right = metrics.rbearing - metrics.width;
 30142           if (metrics.lbearing < 0)
 30143             *left = - metrics.lbearing;
 30144         }
 30145     }
 30146 }
 30147 
 30148 
 30149 /* Return the index of the first glyph preceding glyph string S that
 30150    is overwritten by S because of S's left overhang.  Value is -1
 30151    if no glyphs are overwritten.  */
 30152 
 30153 static int
 30154 left_overwritten (struct glyph_string *s)
 30155 {
 30156   int k;
 30157 
 30158   if (s->left_overhang)
 30159     {
 30160       int x = 0, i;
 30161       struct glyph *glyphs = s->row->glyphs[s->area];
 30162       int first = s->first_glyph - glyphs;
 30163 
 30164       for (i = first - 1; i >= 0 && x > -s->left_overhang; --i)
 30165         x -= glyphs[i].pixel_width;
 30166 
 30167       k = i + 1;
 30168     }
 30169   else
 30170     k = -1;
 30171 
 30172   return k;
 30173 }
 30174 
 30175 
 30176 /* Return the index of the first glyph preceding glyph string S that
 30177    is overwriting S because of its right overhang.  Value is -1 if no
 30178    glyph in front of S overwrites S.  */
 30179 
 30180 static int
 30181 left_overwriting (struct glyph_string *s)
 30182 {
 30183   int i, k, x;
 30184   struct glyph *glyphs = s->row->glyphs[s->area];
 30185   int first = s->first_glyph - glyphs;
 30186 
 30187   k = -1;
 30188   x = 0;
 30189   for (i = first - 1; i >= 0; --i)
 30190     {
 30191       int left, right;
 30192       gui_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
 30193       if (x + right > 0)
 30194         k = i;
 30195       x -= glyphs[i].pixel_width;
 30196     }
 30197 
 30198   return k;
 30199 }
 30200 
 30201 
 30202 /* Return the index of the last glyph following glyph string S that is
 30203    overwritten by S because of S's right overhang.  Value is -1 if
 30204    no such glyph is found.  */
 30205 
 30206 static int
 30207 right_overwritten (struct glyph_string *s)
 30208 {
 30209   int k = -1;
 30210 
 30211   if (s->right_overhang)
 30212     {
 30213       int x = 0, i;
 30214       struct glyph *glyphs = s->row->glyphs[s->area];
 30215       int first = (s->first_glyph - glyphs
 30216                    + (s->first_glyph->type == COMPOSITE_GLYPH ? 1 : s->nchars));
 30217       int end = s->row->used[s->area];
 30218 
 30219       for (i = first; i < end && s->right_overhang > x; ++i)
 30220         x += glyphs[i].pixel_width;
 30221 
 30222       k = i;
 30223     }
 30224 
 30225   return k;
 30226 }
 30227 
 30228 
 30229 /* Return the index of the last glyph following glyph string S that
 30230    overwrites S because of its left overhang.  Value is negative
 30231    if no such glyph is found.  */
 30232 
 30233 static int
 30234 right_overwriting (struct glyph_string *s)
 30235 {
 30236   int i, k, x;
 30237   int end = s->row->used[s->area];
 30238   struct glyph *glyphs = s->row->glyphs[s->area];
 30239   int first = (s->first_glyph - glyphs
 30240                + (s->first_glyph->type == COMPOSITE_GLYPH ? 1 : s->nchars));
 30241 
 30242   k = -1;
 30243   x = 0;
 30244   for (i = first; i < end; ++i)
 30245     {
 30246       int left, right;
 30247       gui_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
 30248       if (x - left < 0)
 30249         k = i;
 30250       x += glyphs[i].pixel_width;
 30251     }
 30252 
 30253   return k;
 30254 }
 30255 
 30256 
 30257 /* Set background width of glyph string S.  START is the index of the
 30258    first glyph following S.  LAST_X is the right-most x-position + 1
 30259    in the drawing area.
 30260 
 30261    If S->hl is DRAW_CURSOR, S->f is a window system frame, and the
 30262    cursor in S's window is currently inside mouse face, also update
 30263    S->width to take into account potentially differing :box
 30264    properties between the original face and the mouse face.  */
 30265 
 30266 static void
 30267 set_glyph_string_background_width (struct glyph_string *s, int start, int last_x)
 30268 {
 30269   /* If the face of this glyph string has to be drawn to the end of
 30270      the drawing area, set S->extends_to_end_of_line_p.  */
 30271 
 30272   if (start == s->row->used[s->area]
 30273       && ((s->row->fill_line_p
 30274            && (s->hl == DRAW_NORMAL_TEXT
 30275                || s->hl == DRAW_IMAGE_RAISED
 30276                || s->hl == DRAW_IMAGE_SUNKEN))
 30277           || s->hl == DRAW_MOUSE_FACE))
 30278     s->extends_to_end_of_line_p = true;
 30279 
 30280   /* If S extends its face to the end of the line, set its
 30281      background_width to the distance to the right edge of the drawing
 30282      area.  */
 30283   if (s->extends_to_end_of_line_p)
 30284     s->background_width = last_x - s->x + 1;
 30285   else
 30286     {
 30287       s->background_width = s->width;
 30288 #ifdef HAVE_WINDOW_SYSTEM
 30289       if (FRAME_WINDOW_P (s->f)
 30290           && s->hl == DRAW_CURSOR
 30291           && MATRIX_ROW (s->w->current_matrix,
 30292                          s->w->phys_cursor.vpos)->mouse_face_p
 30293           && cursor_in_mouse_face_p (s->w))
 30294         {
 30295           /* Adjust the background width of the glyph string, because
 30296              if the glyph's face has the :box attribute, its
 30297              pixel_width might be different when it's displayed in the
 30298              mouse-face, if that also has the :box attribute.  */
 30299           struct glyph *g = s->first_glyph;
 30300           struct face *regular_face = FACE_FROM_ID (s->f, g->face_id);
 30301           s->background_width +=
 30302             adjust_glyph_width_for_mouse_face (g, s->row, s->w,
 30303                                                regular_face, s->face);
 30304           /* S->width is probably worth adjusting here as well.  */
 30305           s->width = s->background_width;
 30306         }
 30307 #endif
 30308     }
 30309 }
 30310 
 30311 
 30312 /* Return glyph string that shares background with glyph string S and
 30313    whose `background_width' member has been set.  */
 30314 
 30315 static struct glyph_string *
 30316 glyph_string_containing_background_width (struct glyph_string *s)
 30317 {
 30318   if (s->cmp)
 30319     while (s->cmp_from)
 30320       s = s->prev;
 30321 
 30322   return s;
 30323 }
 30324 
 30325 
 30326 /* Compute overhangs and x-positions for glyph string S and its
 30327    predecessors, or successors.  X is the starting x-position for S.
 30328    BACKWARD_P means process predecessors.  */
 30329 
 30330 static void
 30331 compute_overhangs_and_x (struct glyph_string *s, int x, bool backward_p)
 30332 {
 30333   if (backward_p)
 30334     {
 30335       while (s)
 30336         {
 30337           if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
 30338             FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
 30339           if (!s->cmp || s->cmp_to == s->cmp->glyph_len)
 30340             x -= s->width;
 30341           s->x = x;
 30342           s = s->prev;
 30343         }
 30344     }
 30345   else
 30346     {
 30347       while (s)
 30348         {
 30349           if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
 30350             FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
 30351           s->x = x;
 30352           if (!s->cmp || s->cmp_to == s->cmp->glyph_len)
 30353             x += s->width;
 30354           s = s->next;
 30355         }
 30356     }
 30357 }
 30358 
 30359 
 30360 
 30361 /* The following macros are only called from draw_glyphs below.
 30362    They reference the following parameters of that function directly:
 30363      `w', `row', `area', and `overlap_p'
 30364    as well as the following local variables:
 30365      `s', `f', and `hdc' (in W32)  */
 30366 
 30367 #ifdef HAVE_NTGUI
 30368 /* On W32, silently add local `hdc' variable to argument list of
 30369    init_glyph_string.  */
 30370 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
 30371   init_glyph_string (s, hdc, char2b, w, row, area, start, hl)
 30372 #else
 30373 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
 30374   init_glyph_string (s, char2b, w, row, area, start, hl)
 30375 #endif
 30376 
 30377 /* Add a glyph string for a stretch glyph to the list of strings
 30378    between HEAD and TAIL.  START is the index of the stretch glyph in
 30379    row area AREA of glyph row ROW.  END is the index of the last glyph
 30380    in that glyph row area.  X is the current output position assigned
 30381    to the new glyph string constructed.  HL overrides that face of the
 30382    glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn.  LAST_X
 30383    is the right-most x-position of the drawing area.  */
 30384 
 30385 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
 30386    and below -- keep them on one line.  */
 30387 #define BUILD_STRETCH_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X)   \
 30388      do                                                                     \
 30389        {                                                                    \
 30390          s = alloca (sizeof *s);                                            \
 30391          INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL);              \
 30392          START = fill_stretch_glyph_string (s, START, END);                 \
 30393          append_glyph_string (&HEAD, &TAIL, s);                             \
 30394          s->x = (X);                                                        \
 30395        }                                                                    \
 30396      while (false)
 30397 
 30398 
 30399 /* Add a glyph string for an image glyph to the list of strings
 30400    between HEAD and TAIL.  START is the index of the image glyph in
 30401    row area AREA of glyph row ROW.  END is the index of the last glyph
 30402    in that glyph row area.  X is the current output position assigned
 30403    to the new glyph string constructed.  HL overrides that face of the
 30404    glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn.  LAST_X
 30405    is the right-most x-position of the drawing area.  */
 30406 
 30407 #define BUILD_IMAGE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30408      do                                                                 \
 30409        {                                                                \
 30410          s = alloca (sizeof *s);                                        \
 30411          INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL);          \
 30412          fill_image_glyph_string (s);                                   \
 30413          append_glyph_string (&HEAD, &TAIL, s);                         \
 30414          ++START;                                                       \
 30415          s->x = (X);                                                    \
 30416        }                                                                \
 30417      while (false)
 30418 
 30419 #ifndef HAVE_XWIDGETS
 30420 # define BUILD_XWIDGET_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30421      eassume (false)
 30422 #else
 30423 # define BUILD_XWIDGET_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30424      do                                                                 \
 30425        {                                                                \
 30426          s = alloca (sizeof *s);                                        \
 30427          INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL);          \
 30428          fill_xwidget_glyph_string (s);                                 \
 30429          append_glyph_string (&(HEAD), &(TAIL), s);                     \
 30430          ++(START);                                                     \
 30431          s->x = (X);                                                    \
 30432        }                                                                \
 30433      while (false)
 30434 #endif
 30435 
 30436 /* Add a glyph string for a sequence of character glyphs to the list
 30437    of strings between HEAD and TAIL.  START is the index of the first
 30438    glyph in row area AREA of glyph row ROW that is part of the new
 30439    glyph string.  END is the index of the last glyph in that glyph row
 30440    area.  X is the current output position assigned to the new glyph
 30441    string constructed.  HL overrides that face of the glyph; e.g. it
 30442    is DRAW_CURSOR if a cursor has to be drawn.  LAST_X is the
 30443    right-most x-position of the drawing area.  */
 30444 
 30445 #define BUILD_CHAR_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X)    \
 30446      do                                                                    \
 30447        {                                                                   \
 30448          int face_id;                                                      \
 30449          unsigned *char2b;                                         \
 30450                                                                            \
 30451          face_id = (row)->glyphs[area][START].face_id;                     \
 30452                                                                            \
 30453          s = alloca (sizeof *s);                                           \
 30454          SAFE_NALLOCA (char2b, 1, (END) - (START));                        \
 30455          INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL);           \
 30456          append_glyph_string (&HEAD, &TAIL, s);                            \
 30457          s->x = (X);                                                       \
 30458          START = fill_glyph_string (s, face_id, START, END, overlaps);     \
 30459        }                                                                   \
 30460      while (false)
 30461 
 30462 
 30463 /* Add a glyph string for a composite sequence to the list of strings
 30464    between HEAD and TAIL.  START is the index of the first glyph in
 30465    row area AREA of glyph row ROW that is part of the new glyph
 30466    string.  END is the index of the last glyph in that glyph row area.
 30467    X is the current output position assigned to the new glyph string
 30468    constructed.  HL overrides that face of the glyph; e.g. it is
 30469    DRAW_CURSOR if a cursor has to be drawn.  LAST_X is the right-most
 30470    x-position of the drawing area.  */
 30471 
 30472 #define BUILD_COMPOSITE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30473   do {                                                                      \
 30474     int face_id = (row)->glyphs[area][START].face_id;                       \
 30475     struct face *base_face = FACE_FROM_ID (f, face_id);             \
 30476     ptrdiff_t cmp_id = (row)->glyphs[area][START].u.cmp.id;                 \
 30477     struct composition *cmp = composition_table[cmp_id];                    \
 30478     unsigned *char2b;                                                       \
 30479     struct glyph_string *first_s = NULL;                                    \
 30480     int n;                                                                  \
 30481                                                                             \
 30482     SAFE_NALLOCA (char2b, 1, cmp->glyph_len);                               \
 30483                                                                             \
 30484     /* Make glyph_strings for each glyph sequence that is drawable by       \
 30485        the same face, and append them to HEAD/TAIL.  */                     \
 30486     for (n = 0; n < cmp->glyph_len;)                                        \
 30487       {                                                                     \
 30488         s = alloca (sizeof *s);                                             \
 30489         INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL);             \
 30490         append_glyph_string (&(HEAD), &(TAIL), s);                          \
 30491         s->cmp = cmp;                                                       \
 30492         s->cmp_from = n;                                                    \
 30493         s->x = (X);                                                         \
 30494         if (n == 0)                                                         \
 30495           first_s = s;                                                      \
 30496         n = fill_composite_glyph_string (s, base_face, overlaps);           \
 30497       }                                                                     \
 30498                                                                             \
 30499     ++START;                                                                \
 30500     s = first_s;                                                            \
 30501   } while (false)
 30502 
 30503 
 30504 /* Add a glyph string for a glyph-string sequence to the list of strings
 30505    between HEAD and TAIL.  */
 30506 
 30507 #define BUILD_GSTRING_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30508   do {                                                                    \
 30509     int face_id;                                                          \
 30510     unsigned *char2b;                                                     \
 30511     Lisp_Object gstring;                                                  \
 30512                                                                           \
 30513     face_id = (row)->glyphs[area][START].face_id;                         \
 30514     gstring = (composition_gstring_from_id                                \
 30515                ((row)->glyphs[area][START].u.cmp.id));                    \
 30516     s = alloca (sizeof *s);                                               \
 30517     SAFE_NALLOCA (char2b, 1, LGSTRING_GLYPH_LEN (gstring));               \
 30518     INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL);               \
 30519     append_glyph_string (&(HEAD), &(TAIL), s);                            \
 30520     s->x = (X);                                                           \
 30521     START = fill_gstring_glyph_string (s, face_id, START, END, overlaps); \
 30522   } while (false)
 30523 
 30524 
 30525 /* Add a glyph string for a sequence of glyphless character's glyphs
 30526    to the list of strings between HEAD and TAIL.  The meanings of
 30527    arguments are the same as those of BUILD_CHAR_GLYPH_STRINGS.  */
 30528 
 30529 #define BUILD_GLYPHLESS_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30530   do                                                                        \
 30531     {                                                                       \
 30532       int face_id;                                                          \
 30533                                                                             \
 30534       face_id = (row)->glyphs[area][START].face_id;                         \
 30535                                                                             \
 30536       s = alloca (sizeof *s);                                               \
 30537       INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL);                 \
 30538       append_glyph_string (&HEAD, &TAIL, s);                                \
 30539       s->x = (X);                                                           \
 30540       START = fill_glyphless_glyph_string (s, face_id, START, END,          \
 30541                                            overlaps);                       \
 30542     }                                                                       \
 30543   while (false)
 30544 
 30545 
 30546 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
 30547    of AREA of glyph row ROW on window W between indices START and END.
 30548    HL overrides the face for drawing glyph strings, e.g. it is
 30549    DRAW_CURSOR to draw a cursor.  X and LAST_X are start and end
 30550    x-positions of the drawing area.
 30551 
 30552    This is an ugly monster macro construct because we must use alloca
 30553    to allocate glyph strings (because draw_glyphs can be called
 30554    asynchronously).  */
 30555 
 30556 #define BUILD_GLYPH_STRINGS_1(START, END, HEAD, TAIL, HL, X, LAST_X)    \
 30557   do                                                                    \
 30558     {                                                                   \
 30559       HEAD = TAIL = NULL;                                               \
 30560       while (START < END)                                               \
 30561         {                                                               \
 30562           struct glyph *first_glyph = (row)->glyphs[area] + START;      \
 30563           switch (first_glyph->type)                                    \
 30564             {                                                           \
 30565             case CHAR_GLYPH:                                            \
 30566               BUILD_CHAR_GLYPH_STRINGS (START, END, HEAD, TAIL,         \
 30567                                         HL, X, LAST_X);                 \
 30568               break;                                                    \
 30569                                                                         \
 30570             case COMPOSITE_GLYPH:                                       \
 30571               if (first_glyph->u.cmp.automatic)                         \
 30572                 BUILD_GSTRING_GLYPH_STRING (START, END, HEAD, TAIL,     \
 30573                                             HL, X, LAST_X);             \
 30574               else                                                      \
 30575                 BUILD_COMPOSITE_GLYPH_STRING (START, END, HEAD, TAIL,   \
 30576                                               HL, X, LAST_X);           \
 30577               break;                                                    \
 30578                                                                         \
 30579             case STRETCH_GLYPH:                                         \
 30580               BUILD_STRETCH_GLYPH_STRING (START, END, HEAD, TAIL,       \
 30581                                           HL, X, LAST_X);               \
 30582               break;                                                    \
 30583                                                                         \
 30584             case IMAGE_GLYPH:                                           \
 30585               BUILD_IMAGE_GLYPH_STRING (START, END, HEAD, TAIL,         \
 30586                                         HL, X, LAST_X);                 \
 30587               break;
 30588 
 30589 #define BUILD_GLYPH_STRINGS_XW(START, END, HEAD, TAIL, HL, X, LAST_X)   \
 30590             case XWIDGET_GLYPH:                                         \
 30591               BUILD_XWIDGET_GLYPH_STRING (START, END, HEAD, TAIL,       \
 30592                                           HL, X, LAST_X);               \
 30593               break;
 30594 
 30595 #define BUILD_GLYPH_STRINGS_2(START, END, HEAD, TAIL, HL, X, LAST_X)    \
 30596             case GLYPHLESS_GLYPH:                                       \
 30597               BUILD_GLYPHLESS_GLYPH_STRING (START, END, HEAD, TAIL,     \
 30598                                             HL, X, LAST_X);             \
 30599               break;                                                    \
 30600                                                                         \
 30601             default:                                                    \
 30602               emacs_abort ();                                           \
 30603             }                                                           \
 30604                                                                         \
 30605           if (s)                                                        \
 30606             {                                                           \
 30607               set_glyph_string_background_width (s, START, LAST_X);     \
 30608               (X) += s->width;                                          \
 30609             }                                                           \
 30610         }                                                               \
 30611     } while (false)
 30612 
 30613 
 30614 #define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X)      \
 30615     BUILD_GLYPH_STRINGS_1(START, END, HEAD, TAIL, HL, X, LAST_X)        \
 30616     BUILD_GLYPH_STRINGS_XW(START, END, HEAD, TAIL, HL, X, LAST_X)       \
 30617     BUILD_GLYPH_STRINGS_2(START, END, HEAD, TAIL, HL, X, LAST_X)
 30618 
 30619 
 30620 /* Draw glyphs between START and END in AREA of ROW on window W,
 30621    starting at x-position X.  X is relative to AREA in W.  HL is a
 30622    face-override with the following meaning:
 30623 
 30624    DRAW_NORMAL_TEXT     draw normally
 30625    DRAW_CURSOR          draw in cursor face
 30626    DRAW_MOUSE_FACE      draw in mouse face.
 30627    DRAW_INVERSE_VIDEO   draw in mode line face
 30628    DRAW_IMAGE_SUNKEN    draw an image with a sunken relief around it
 30629    DRAW_IMAGE_RAISED    draw an image with a raised relief around it
 30630 
 30631    If OVERLAPS is non-zero, draw only the foreground of characters and
 30632    clip to the physical height of ROW.  Non-zero value also defines
 30633    the overlapping part to be drawn:
 30634 
 30635    OVERLAPS_PRED                overlap with preceding rows
 30636    OVERLAPS_SUCC                overlap with succeeding rows
 30637    OVERLAPS_BOTH                overlap with both preceding/succeeding rows
 30638    OVERLAPS_ERASED_CURSOR       overlap with erased cursor area
 30639 
 30640    Value is the x-position reached, relative to AREA of W.  */
 30641 
 30642 static int
 30643 draw_glyphs (struct window *w, int x, struct glyph_row *row,
 30644              enum glyph_row_area area, ptrdiff_t start, ptrdiff_t end,
 30645              enum draw_glyphs_face hl, int overlaps)
 30646 {
 30647   struct glyph_string *head, *tail;
 30648   struct glyph_string *s;
 30649   struct glyph_string *clip_head = NULL, *clip_tail = NULL;
 30650   int i, j, x_reached, last_x, area_left = 0;
 30651   struct frame *f = XFRAME (WINDOW_FRAME (w));
 30652 
 30653   ALLOCATE_HDC (hdc, f);
 30654 
 30655   /* Let's rather be paranoid than getting a SEGV.  */
 30656   end = min (end, row->used[area]);
 30657   start = clip_to_bounds (0, start, end);
 30658 
 30659   /* Translate X to frame coordinates.  Set last_x to the right
 30660      end of the drawing area.  */
 30661   if (row->full_width_p)
 30662     {
 30663       /* X is relative to the left edge of W, without scroll bars
 30664          or fringes.  */
 30665       area_left = WINDOW_LEFT_EDGE_X (w);
 30666       last_x = (WINDOW_LEFT_EDGE_X (w) + WINDOW_PIXEL_WIDTH (w)
 30667                 - (row->mode_line_p ? WINDOW_RIGHT_DIVIDER_WIDTH (w) : 0));
 30668     }
 30669   else
 30670     {
 30671       area_left = window_box_left (w, area);
 30672       last_x = area_left + window_box_width (w, area);
 30673     }
 30674   x += area_left;
 30675 
 30676   /* Build a doubly-linked list of glyph_string structures between
 30677      head and tail from what we have to draw.  Note that the macro
 30678      BUILD_GLYPH_STRINGS will modify its start parameter.  That's
 30679      the reason we use a separate variable `i'.  */
 30680   i = start;
 30681   USE_SAFE_ALLOCA;
 30682   BUILD_GLYPH_STRINGS (i, end, head, tail, hl, x, last_x);
 30683   if (tail)
 30684     {
 30685       s = glyph_string_containing_background_width (tail);
 30686       x_reached = s->x + s->background_width;
 30687     }
 30688   else
 30689     x_reached = x;
 30690 
 30691   /* If there are any glyphs with lbearing < 0 or rbearing > width in
 30692      the row, redraw some glyphs in front or following the glyph
 30693      strings built above.  */
 30694   if (head && !overlaps && row->contains_overlapping_glyphs_p)
 30695     {
 30696       struct glyph_string *h, *t;
 30697       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 30698       int mouse_beg_col UNINIT, mouse_end_col UNINIT;
 30699       bool check_mouse_face = false;
 30700       int dummy_x = 0;
 30701 
 30702       /* If mouse highlighting is on, we may need to draw adjacent
 30703          glyphs using mouse-face highlighting.  */
 30704       if (area == TEXT_AREA && row->mouse_face_p
 30705           && hlinfo->mouse_face_beg_row >= 0
 30706           && hlinfo->mouse_face_end_row >= 0)
 30707         {
 30708           ptrdiff_t row_vpos = MATRIX_ROW_VPOS (row, w->current_matrix);
 30709 
 30710           if (row_vpos >= hlinfo->mouse_face_beg_row
 30711               && row_vpos <= hlinfo->mouse_face_end_row)
 30712             {
 30713               check_mouse_face = true;
 30714               mouse_beg_col = (row_vpos == hlinfo->mouse_face_beg_row)
 30715                 ? hlinfo->mouse_face_beg_col : 0;
 30716               mouse_end_col = (row_vpos == hlinfo->mouse_face_end_row)
 30717                 ? hlinfo->mouse_face_end_col
 30718                 : row->used[TEXT_AREA];
 30719             }
 30720         }
 30721 
 30722       /* Compute overhangs for all glyph strings.  */
 30723       if (FRAME_RIF (f)->compute_glyph_string_overhangs)
 30724         for (s = head; s; s = s->next)
 30725           FRAME_RIF (f)->compute_glyph_string_overhangs (s);
 30726 
 30727       /* Prepend glyph strings for glyphs in front of the first glyph
 30728          string that are overwritten because of the first glyph
 30729          string's left overhang.  The background of all strings
 30730          prepended must be drawn because the first glyph string
 30731          draws over it.  */
 30732       i = left_overwritten (head);
 30733       if (i >= 0)
 30734         {
 30735           enum draw_glyphs_face overlap_hl;
 30736 
 30737           /* If this row contains mouse highlighting, attempt to draw
 30738              the overlapped glyphs with the correct highlight.  This
 30739              code fails if the overlap encompasses more than one glyph
 30740              and mouse-highlight spans only some of these glyphs.
 30741              However, making it work perfectly involves a lot more
 30742              code, and I don't know if the pathological case occurs in
 30743              practice, so we'll stick to this for now.  --- cyd  */
 30744           if (check_mouse_face
 30745               && mouse_beg_col < start && mouse_end_col > i)
 30746             overlap_hl = DRAW_MOUSE_FACE;
 30747           else
 30748             overlap_hl = DRAW_NORMAL_TEXT;
 30749 
 30750           if (hl != overlap_hl)
 30751             clip_head = head;
 30752           j = i;
 30753           BUILD_GLYPH_STRINGS (j, start, h, t,
 30754                                overlap_hl, dummy_x, last_x);
 30755           start = i;
 30756           compute_overhangs_and_x (t, head->x, true);
 30757           prepend_glyph_string_lists (&head, &tail, h, t);
 30758           if (clip_head == NULL)
 30759             clip_head = head;
 30760         }
 30761 
 30762       /* Prepend glyph strings for glyphs in front of the first glyph
 30763          string that overwrite that glyph string because of their
 30764          right overhang.  For these strings, only the foreground must
 30765          be drawn, because it draws over the glyph string at `head'.
 30766          The background must not be drawn because this would overwrite
 30767          right overhangs of preceding glyphs for which no glyph
 30768          strings exist.  */
 30769       i = left_overwriting (head);
 30770       if (i >= 0)
 30771         {
 30772           enum draw_glyphs_face overlap_hl;
 30773 
 30774           if (check_mouse_face
 30775               && mouse_beg_col < start && mouse_end_col > i)
 30776             overlap_hl = DRAW_MOUSE_FACE;
 30777           else
 30778             overlap_hl = DRAW_NORMAL_TEXT;
 30779 
 30780           if (hl == overlap_hl || clip_head == NULL)
 30781             clip_head = head;
 30782           BUILD_GLYPH_STRINGS (i, start, h, t,
 30783                                overlap_hl, dummy_x, last_x);
 30784           for (s = h; s; s = s->next)
 30785             s->background_filled_p = true;
 30786           compute_overhangs_and_x (t, head->x, true);
 30787           prepend_glyph_string_lists (&head, &tail, h, t);
 30788         }
 30789 
 30790       /* Append glyphs strings for glyphs following the last glyph
 30791          string tail that are overwritten by tail.  The background of
 30792          these strings has to be drawn because tail's foreground draws
 30793          over it.  */
 30794       i = right_overwritten (tail);
 30795       if (i >= 0)
 30796         {
 30797           enum draw_glyphs_face overlap_hl;
 30798 
 30799           if (check_mouse_face
 30800               && mouse_beg_col < i && mouse_end_col > end)
 30801             overlap_hl = DRAW_MOUSE_FACE;
 30802           else
 30803             overlap_hl = DRAW_NORMAL_TEXT;
 30804 
 30805           if (hl != overlap_hl)
 30806             clip_tail = tail;
 30807           BUILD_GLYPH_STRINGS (end, i, h, t,
 30808                                overlap_hl, x, last_x);
 30809           /* Because BUILD_GLYPH_STRINGS updates the first argument,
 30810              we don't have `end = i;' here.  */
 30811           compute_overhangs_and_x (h, tail->x + tail->width, false);
 30812           append_glyph_string_lists (&head, &tail, h, t);
 30813           if (clip_tail == NULL)
 30814             clip_tail = tail;
 30815         }
 30816 
 30817       /* Append glyph strings for glyphs following the last glyph
 30818          string tail that overwrite tail.  The foreground of such
 30819          glyphs has to be drawn because it writes into the background
 30820          of tail.  The background must not be drawn because it could
 30821          paint over the foreground of following glyphs.  */
 30822       i = right_overwriting (tail);
 30823       if (i >= 0)
 30824         {
 30825           enum draw_glyphs_face overlap_hl;
 30826           if (check_mouse_face
 30827               && mouse_beg_col < i && mouse_end_col > end)
 30828             overlap_hl = DRAW_MOUSE_FACE;
 30829           else
 30830             overlap_hl = DRAW_NORMAL_TEXT;
 30831 
 30832           if (hl == overlap_hl || clip_tail == NULL)
 30833             clip_tail = tail;
 30834           i++;                  /* We must include the Ith glyph.  */
 30835           BUILD_GLYPH_STRINGS (end, i, h, t,
 30836                                overlap_hl, x, last_x);
 30837           for (s = h; s; s = s->next)
 30838             s->background_filled_p = true;
 30839           compute_overhangs_and_x (h, tail->x + tail->width, false);
 30840           append_glyph_string_lists (&head, &tail, h, t);
 30841         }
 30842       tail = glyph_string_containing_background_width (tail);
 30843       if (clip_tail)
 30844         clip_tail = glyph_string_containing_background_width (clip_tail);
 30845       if (clip_head || clip_tail)
 30846         for (s = head; s; s = s->next)
 30847           {
 30848             s->clip_head = clip_head;
 30849             s->clip_tail = clip_tail;
 30850           }
 30851     }
 30852 
 30853   /* Draw all strings.  */
 30854   for (s = head; s; s = s->next)
 30855     FRAME_RIF (f)->draw_glyph_string (s);
 30856 
 30857   /* When focus a sole frame and move horizontally, this clears on_p
 30858      causing a failure to erase prev cursor position. */
 30859   if (area == TEXT_AREA
 30860       && !row->full_width_p
 30861       /* When drawing overlapping rows, only the glyph strings'
 30862          foreground is drawn, which doesn't erase a cursor
 30863          completely. */
 30864       && !overlaps)
 30865     {
 30866       int x0 = clip_head ? clip_head->x : (head ? head->x : x);
 30867       int x1 = (clip_tail ? clip_tail->x + clip_tail->background_width
 30868                 : (tail ? tail->x + tail->background_width : x));
 30869       x0 -= area_left;
 30870       x1 -= area_left;
 30871 
 30872       notice_overwritten_cursor (w, TEXT_AREA, x0, x1,
 30873                                  row->y, MATRIX_ROW_BOTTOM_Y (row));
 30874     }
 30875 
 30876   /* Value is the x-position up to which drawn, relative to AREA of W.
 30877      This doesn't include parts drawn because of overhangs.  */
 30878   if (row->full_width_p)
 30879     x_reached = FRAME_TO_WINDOW_PIXEL_X (w, x_reached);
 30880   else
 30881     x_reached -= area_left;
 30882 
 30883   RELEASE_HDC (hdc, f);
 30884 
 30885   SAFE_FREE ();
 30886   return x_reached;
 30887 }
 30888 
 30889 /* Find the first glyph in the run of underlined glyphs preceding the
 30890    beginning of glyph string S, and return its font (which could be
 30891    NULL).  This is needed because that font determines the underline
 30892    position and thickness for the entire run of the underlined glyphs.
 30893    This function is called from the draw_glyph_string method of GUI
 30894    frame's redisplay interface (RIF) when it needs to draw in an
 30895    underlined face.  */
 30896 struct font *
 30897 font_for_underline_metrics (struct glyph_string *s)
 30898 {
 30899   struct glyph *g0 = s->row->glyphs[s->area], *g;
 30900 
 30901   for (g = s->first_glyph - 1; g >= g0; g--)
 30902     {
 30903       struct face *prev_face = FACE_FROM_ID (s->f, g->face_id);
 30904       if (!(prev_face && prev_face->underline != FACE_NO_UNDERLINE))
 30905         break;
 30906     }
 30907 
 30908   /* If preceding glyphs are not underlined, use the font of S.  */
 30909   if (g == s->first_glyph - 1)
 30910     return s->font;
 30911   else
 30912     {
 30913       /* Otherwise use the font of the last glyph we saw in the above
 30914          loop whose face had the underline_p flag set.  */
 30915       return FACE_FROM_ID (s->f, g[1].face_id)->font;
 30916     }
 30917 }
 30918 
 30919 /* Expand row matrix if too narrow.  Don't expand if area
 30920    is not present.  */
 30921 
 30922 #define IT_EXPAND_MATRIX_WIDTH(it, area)                \
 30923   {                                                     \
 30924     if (!it->f->fonts_changed                           \
 30925         && (it->glyph_row->glyphs[area]                 \
 30926             < it->glyph_row->glyphs[area + 1]))         \
 30927       {                                                 \
 30928         it->w->ncols_scale_factor++;                    \
 30929         it->f->fonts_changed = true;                    \
 30930       }                                                 \
 30931   }
 30932 
 30933 /* Store one glyph for IT->char_to_display in IT->glyph_row.
 30934    Called from gui_produce_glyphs when IT->glyph_row is non-null.  */
 30935 
 30936 static void
 30937 append_glyph (struct it *it)
 30938 {
 30939   struct glyph *glyph;
 30940   enum glyph_row_area area = it->area;
 30941 
 30942   eassert (it->glyph_row);
 30943   eassert (it->char_to_display != '\n' && it->char_to_display != '\t');
 30944 
 30945   glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 30946   if (glyph < it->glyph_row->glyphs[area + 1])
 30947     {
 30948       /* If the glyph row is reversed, we need to prepend the glyph
 30949          rather than append it.  */
 30950       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 30951         {
 30952           struct glyph *g;
 30953 
 30954           /* Make room for the additional glyph.  */
 30955           for (g = glyph - 1; g >= it->glyph_row->glyphs[area]; g--)
 30956             g[1] = *g;
 30957           glyph = it->glyph_row->glyphs[area];
 30958         }
 30959       glyph->charpos = CHARPOS (it->position);
 30960       glyph->object = it->object;
 30961       if (it->pixel_width > 0)
 30962         {
 30963           eassert (it->pixel_width <= SHRT_MAX);
 30964           glyph->pixel_width = it->pixel_width;
 30965           glyph->padding_p = false;
 30966         }
 30967       else
 30968         {
 30969           /* Assure at least 1-pixel width.  Otherwise, cursor can't
 30970              be displayed correctly.  */
 30971           glyph->pixel_width = 1;
 30972           glyph->padding_p = true;
 30973         }
 30974       glyph->ascent = it->ascent;
 30975       glyph->descent = it->descent;
 30976       glyph->voffset = it->voffset;
 30977       glyph->type = CHAR_GLYPH;
 30978       glyph->avoid_cursor_p = it->avoid_cursor_p;
 30979       glyph->multibyte_p = it->multibyte_p;
 30980       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 30981         {
 30982           /* In R2L rows, the left and the right box edges need to be
 30983              drawn in reverse direction.  */
 30984           glyph->right_box_line_p = it->start_of_box_run_p;
 30985           glyph->left_box_line_p = it->end_of_box_run_p;
 30986         }
 30987       else
 30988         {
 30989           glyph->left_box_line_p = it->start_of_box_run_p;
 30990           glyph->right_box_line_p = it->end_of_box_run_p;
 30991         }
 30992       glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
 30993                                       || it->phys_descent > it->descent);
 30994       glyph->glyph_not_available_p = it->glyph_not_available_p;
 30995       glyph->face_id = it->face_id;
 30996       glyph->u.ch = it->char_to_display;
 30997       glyph->slice.img = null_glyph_slice;
 30998       glyph->font_type = FONT_TYPE_UNKNOWN;
 30999       if (it->bidi_p)
 31000         {
 31001           glyph->resolved_level = it->bidi_it.resolved_level;
 31002           eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 31003           glyph->bidi_type = it->bidi_it.type;
 31004         }
 31005       else
 31006         {
 31007           glyph->resolved_level = 0;
 31008           glyph->bidi_type = UNKNOWN_BT;
 31009         }
 31010       ++it->glyph_row->used[area];
 31011     }
 31012   else
 31013     IT_EXPAND_MATRIX_WIDTH (it, area);
 31014 }
 31015 
 31016 /* Store one glyph for the composition IT->cmp_it.id in IT->glyph_row.
 31017    Called from gui_produce_glyphs when IT->glyph_row is non-null.  */
 31018 
 31019 static void
 31020 append_composite_glyph (struct it *it)
 31021 {
 31022   struct glyph *glyph;
 31023   enum glyph_row_area area = it->area;
 31024 
 31025   eassert (it->glyph_row);
 31026 
 31027   glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 31028   if (glyph < it->glyph_row->glyphs[area + 1])
 31029     {
 31030       /* If the glyph row is reversed, we need to prepend the glyph
 31031          rather than append it.  */
 31032       if (it->glyph_row->reversed_p && it->area == TEXT_AREA)
 31033         {
 31034           struct glyph *g;
 31035 
 31036           /* Make room for the new glyph.  */
 31037           for (g = glyph - 1; g >= it->glyph_row->glyphs[it->area]; g--)
 31038             g[1] = *g;
 31039           glyph = it->glyph_row->glyphs[it->area];
 31040         }
 31041       glyph->charpos = it->cmp_it.charpos;
 31042       glyph->object = it->object;
 31043       eassert (it->pixel_width <= SHRT_MAX);
 31044       glyph->pixel_width = it->pixel_width;
 31045       glyph->ascent = it->ascent;
 31046       glyph->descent = it->descent;
 31047       glyph->voffset = it->voffset;
 31048       glyph->type = COMPOSITE_GLYPH;
 31049       if (it->cmp_it.ch < 0)
 31050         {
 31051           glyph->u.cmp.automatic = false;
 31052           glyph->u.cmp.id = it->cmp_it.id;
 31053           glyph->slice.cmp.from = glyph->slice.cmp.to = 0;
 31054         }
 31055       else
 31056         {
 31057           glyph->u.cmp.automatic = true;
 31058           glyph->u.cmp.id = it->cmp_it.id;
 31059           glyph->slice.cmp.from = it->cmp_it.from;
 31060           glyph->slice.cmp.to = it->cmp_it.to - 1;
 31061         }
 31062       glyph->avoid_cursor_p = it->avoid_cursor_p;
 31063       glyph->multibyte_p = it->multibyte_p;
 31064       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31065         {
 31066           /* In R2L rows, the left and the right box edges need to be
 31067              drawn in reverse direction.  */
 31068           glyph->right_box_line_p = it->start_of_box_run_p;
 31069           glyph->left_box_line_p = it->end_of_box_run_p;
 31070         }
 31071       else
 31072         {
 31073           glyph->left_box_line_p = it->start_of_box_run_p;
 31074           glyph->right_box_line_p = it->end_of_box_run_p;
 31075         }
 31076       glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
 31077                                       || it->phys_descent > it->descent);
 31078       glyph->padding_p = false;
 31079       glyph->glyph_not_available_p = it->glyph_not_available_p;
 31080       glyph->face_id = it->face_id;
 31081       glyph->font_type = FONT_TYPE_UNKNOWN;
 31082       if (it->bidi_p)
 31083         {
 31084           glyph->resolved_level = it->bidi_it.resolved_level;
 31085           eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 31086           glyph->bidi_type = it->bidi_it.type;
 31087         }
 31088       ++it->glyph_row->used[area];
 31089     }
 31090   else
 31091     IT_EXPAND_MATRIX_WIDTH (it, area);
 31092 }
 31093 
 31094 
 31095 /* Change IT->ascent and IT->height according to the setting of
 31096    IT->voffset.  */
 31097 
 31098 static void
 31099 take_vertical_position_into_account (struct it *it)
 31100 {
 31101   if (it->voffset)
 31102     {
 31103       if (it->voffset < 0)
 31104         /* Increase the ascent so that we can display the text higher
 31105            in the line.  */
 31106         it->ascent -= it->voffset;
 31107       else
 31108         /* Increase the descent so that we can display the text lower
 31109            in the line.  */
 31110         it->descent += it->voffset;
 31111     }
 31112 }
 31113 
 31114 
 31115 /* Produce glyphs/get display metrics for the image IT is loaded with.
 31116    See the description of struct display_iterator in dispextern.h for
 31117    an overview of struct display_iterator.  */
 31118 
 31119 static void
 31120 produce_image_glyph (struct it *it)
 31121 {
 31122   struct image *img;
 31123   struct face *face;
 31124   int glyph_ascent, crop;
 31125   struct glyph_slice slice;
 31126 
 31127   eassert (it->what == IT_IMAGE);
 31128 
 31129   face = FACE_FROM_ID (it->f, it->face_id);
 31130   /* Make sure X resources of the face is loaded.  */
 31131   prepare_face_for_display (it->f, face);
 31132 
 31133   if (it->image_id < 0)
 31134     {
 31135       /* Fringe bitmap.  */
 31136       it->ascent = it->phys_ascent = 0;
 31137       it->descent = it->phys_descent = 0;
 31138       it->pixel_width = 0;
 31139       it->nglyphs = 0;
 31140       return;
 31141     }
 31142 
 31143   img = IMAGE_FROM_ID (it->f, it->image_id);
 31144   /* Make sure X resources of the image is loaded.  */
 31145   prepare_image_for_display (it->f, img);
 31146 
 31147   slice.x = slice.y = 0;
 31148   slice.width = img->width;
 31149   slice.height = img->height;
 31150 
 31151   if (FIXNUMP (it->slice.x))
 31152     slice.x = XFIXNUM (it->slice.x);
 31153   else if (FLOATP (it->slice.x))
 31154     slice.x = XFLOAT_DATA (it->slice.x) * img->width;
 31155 
 31156   if (FIXNUMP (it->slice.y))
 31157     slice.y = XFIXNUM (it->slice.y);
 31158   else if (FLOATP (it->slice.y))
 31159     slice.y = XFLOAT_DATA (it->slice.y) * img->height;
 31160 
 31161   if (FIXNUMP (it->slice.width))
 31162     slice.width = XFIXNUM (it->slice.width);
 31163   else if (FLOATP (it->slice.width))
 31164     slice.width = XFLOAT_DATA (it->slice.width) * img->width;
 31165 
 31166   if (FIXNUMP (it->slice.height))
 31167     slice.height = XFIXNUM (it->slice.height);
 31168   else if (FLOATP (it->slice.height))
 31169     slice.height = XFLOAT_DATA (it->slice.height) * img->height;
 31170 
 31171   if (slice.x >= img->width)
 31172     slice.x = img->width;
 31173   if (slice.y >= img->height)
 31174     slice.y = img->height;
 31175   if (slice.x + slice.width >= img->width)
 31176     slice.width = img->width - slice.x;
 31177   if (slice.y + slice.height > img->height)
 31178     slice.height = img->height - slice.y;
 31179 
 31180   if (slice.width == 0 || slice.height == 0)
 31181     return;
 31182 
 31183   it->ascent = it->phys_ascent = glyph_ascent = image_ascent (img, face, &slice);
 31184 
 31185   it->descent = slice.height - glyph_ascent;
 31186   if (slice.y == 0)
 31187     it->descent += img->vmargin;
 31188   if (slice.y + slice.height == img->height)
 31189     it->descent += img->vmargin;
 31190   it->phys_descent = it->descent;
 31191 
 31192   it->pixel_width = slice.width;
 31193   if (slice.x == 0)
 31194     it->pixel_width += img->hmargin;
 31195   if (slice.x + slice.width == img->width)
 31196     it->pixel_width += img->hmargin;
 31197 
 31198   /* It's quite possible for images to have an ascent greater than
 31199      their height, so don't get confused in that case.  */
 31200   if (it->descent < 0)
 31201     it->descent = 0;
 31202 
 31203   it->nglyphs = 1;
 31204 
 31205   if (face->box != FACE_NO_BOX)
 31206     {
 31207       /* If you change the logic here, please change it in
 31208          get_cursor_offset_for_mouse_face as well. */
 31209       if (face->box_horizontal_line_width > 0)
 31210         {
 31211           if (slice.y == 0)
 31212             it->ascent += face->box_horizontal_line_width;
 31213           if (slice.y + slice.height == img->height)
 31214             it->descent += face->box_horizontal_line_width;
 31215         }
 31216 
 31217       if (face->box_vertical_line_width > 0)
 31218         {
 31219           if (it->start_of_box_run_p && slice.x == 0)
 31220             it->pixel_width += face->box_vertical_line_width;
 31221           if (it->end_of_box_run_p && slice.x + slice.width == img->width)
 31222             it->pixel_width += face->box_vertical_line_width;
 31223         }
 31224     }
 31225 
 31226   take_vertical_position_into_account (it);
 31227 
 31228   /* Automatically crop wide image glyphs at right edge so we can
 31229      draw the cursor on same display row.  */
 31230   if ((crop = it->pixel_width - (it->last_visible_x - it->current_x), crop > 0)
 31231       && (it->hpos == 0 || it->pixel_width > it->last_visible_x / 4))
 31232     {
 31233       it->pixel_width -= crop;
 31234       slice.width -= crop;
 31235     }
 31236 
 31237   if (it->glyph_row)
 31238     {
 31239       struct glyph *glyph;
 31240       enum glyph_row_area area = it->area;
 31241 
 31242       glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 31243       if (it->glyph_row->reversed_p)
 31244         {
 31245           struct glyph *g;
 31246 
 31247           /* Make room for the new glyph.  */
 31248           for (g = glyph - 1; g >= it->glyph_row->glyphs[it->area]; g--)
 31249             g[1] = *g;
 31250           glyph = it->glyph_row->glyphs[it->area];
 31251         }
 31252       if (glyph < it->glyph_row->glyphs[area + 1])
 31253         {
 31254           glyph->charpos = CHARPOS (it->position);
 31255           glyph->object = it->object;
 31256           glyph->pixel_width = clip_to_bounds (-1, it->pixel_width, SHRT_MAX);
 31257           glyph->ascent = glyph_ascent;
 31258           glyph->descent = it->descent;
 31259           glyph->voffset = it->voffset;
 31260           glyph->type = IMAGE_GLYPH;
 31261           glyph->avoid_cursor_p = it->avoid_cursor_p;
 31262           glyph->multibyte_p = it->multibyte_p;
 31263           if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31264             {
 31265               /* In R2L rows, the left and the right box edges need to be
 31266                  drawn in reverse direction.  */
 31267               glyph->right_box_line_p = it->start_of_box_run_p;
 31268               glyph->left_box_line_p = it->end_of_box_run_p;
 31269             }
 31270           else
 31271             {
 31272               glyph->left_box_line_p = it->start_of_box_run_p;
 31273               glyph->right_box_line_p = it->end_of_box_run_p;
 31274             }
 31275           glyph->overlaps_vertically_p = false;
 31276           glyph->padding_p = false;
 31277           glyph->glyph_not_available_p = false;
 31278           glyph->face_id = it->face_id;
 31279           glyph->u.img_id = img->id;
 31280           glyph->slice.img = slice;
 31281           glyph->font_type = FONT_TYPE_UNKNOWN;
 31282           if (it->bidi_p)
 31283             {
 31284               glyph->resolved_level = it->bidi_it.resolved_level;
 31285               eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 31286               glyph->bidi_type = it->bidi_it.type;
 31287             }
 31288           ++it->glyph_row->used[area];
 31289         }
 31290       else
 31291         IT_EXPAND_MATRIX_WIDTH (it, area);
 31292     }
 31293 }
 31294 
 31295 static void
 31296 produce_xwidget_glyph (struct it *it)
 31297 {
 31298 #ifdef HAVE_XWIDGETS
 31299   struct xwidget *xw;
 31300   int glyph_ascent, crop;
 31301   eassert (it->what == IT_XWIDGET);
 31302 
 31303   struct face *face = FACE_FROM_ID (it->f, it->face_id);
 31304   /* Make sure X resources of the face is loaded.  */
 31305   prepare_face_for_display (it->f, face);
 31306 
 31307   xw = it->xwidget;
 31308   it->ascent = it->phys_ascent = glyph_ascent = xw->height/2;
 31309   it->descent = xw->height/2;
 31310   it->phys_descent = it->descent;
 31311   it->pixel_width = xw->width;
 31312   /* It's quite possible for images to have an ascent greater than
 31313      their height, so don't get confused in that case.  */
 31314   if (it->descent < 0)
 31315     it->descent = 0;
 31316 
 31317   it->nglyphs = 1;
 31318 
 31319   if (face->box != FACE_NO_BOX)
 31320     {
 31321       if (face->box_horizontal_line_width > 0)
 31322         {
 31323           it->ascent += face->box_horizontal_line_width;
 31324           it->descent += face->box_horizontal_line_width;
 31325         }
 31326 
 31327       if (face->box_vertical_line_width > 0)
 31328         {
 31329           if (it->start_of_box_run_p)
 31330             it->pixel_width += face->box_vertical_line_width;
 31331           it->pixel_width += face->box_vertical_line_width;
 31332         }
 31333     }
 31334 
 31335   take_vertical_position_into_account (it);
 31336 
 31337   /* Automatically crop wide image glyphs at right edge so we can
 31338      draw the cursor on same display row.  */
 31339   crop = it->pixel_width - (it->last_visible_x - it->current_x);
 31340   if (crop > 0 && (it->hpos == 0 || it->pixel_width > it->last_visible_x / 4))
 31341     it->pixel_width -= crop;
 31342 
 31343   if (it->glyph_row)
 31344     {
 31345       enum glyph_row_area area = it->area;
 31346       struct glyph *glyph
 31347         = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 31348 
 31349       if (it->glyph_row->reversed_p)
 31350         {
 31351           struct glyph *g;
 31352 
 31353           /* Make room for the new glyph.  */
 31354           for (g = glyph - 1; g >= it->glyph_row->glyphs[it->area]; g--)
 31355             g[1] = *g;
 31356           glyph = it->glyph_row->glyphs[it->area];
 31357         }
 31358       if (glyph < it->glyph_row->glyphs[area + 1])
 31359         {
 31360           glyph->charpos = CHARPOS (it->position);
 31361           glyph->object = it->object;
 31362           glyph->pixel_width = clip_to_bounds (-1, it->pixel_width, SHRT_MAX);
 31363           glyph->ascent = glyph_ascent;
 31364           glyph->descent = it->descent;
 31365           glyph->voffset = it->voffset;
 31366           glyph->type = XWIDGET_GLYPH;
 31367           glyph->avoid_cursor_p = it->avoid_cursor_p;
 31368           glyph->multibyte_p = it->multibyte_p;
 31369           if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31370             {
 31371               /* In R2L rows, the left and the right box edges need to be
 31372                  drawn in reverse direction.  */
 31373               glyph->right_box_line_p = it->start_of_box_run_p;
 31374               glyph->left_box_line_p = it->end_of_box_run_p;
 31375             }
 31376           else
 31377             {
 31378               glyph->left_box_line_p = it->start_of_box_run_p;
 31379               glyph->right_box_line_p = it->end_of_box_run_p;
 31380             }
 31381           glyph->overlaps_vertically_p = 0;
 31382           glyph->padding_p = 0;
 31383           glyph->glyph_not_available_p = 0;
 31384           glyph->face_id = it->face_id;
 31385           glyph->u.xwidget = it->xwidget->xwidget_id;
 31386           glyph->font_type = FONT_TYPE_UNKNOWN;
 31387           if (it->bidi_p)
 31388             {
 31389               glyph->resolved_level = it->bidi_it.resolved_level;
 31390               eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 31391               glyph->bidi_type = it->bidi_it.type;
 31392             }
 31393           ++it->glyph_row->used[area];
 31394         }
 31395       else
 31396         IT_EXPAND_MATRIX_WIDTH (it, area);
 31397     }
 31398 #endif
 31399 }
 31400 
 31401 /* Append a stretch glyph to IT->glyph_row.  OBJECT is the source
 31402    of the glyph, WIDTH and HEIGHT are the width and height of the
 31403    stretch.  ASCENT is the ascent of the glyph (0 <= ASCENT <= HEIGHT).  */
 31404 
 31405 static void
 31406 append_stretch_glyph (struct it *it, Lisp_Object object,
 31407                       int width, int height, int ascent)
 31408 {
 31409   struct glyph *glyph;
 31410   enum glyph_row_area area = it->area;
 31411 
 31412   eassert (ascent >= 0 && ascent <= height);
 31413 
 31414   glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 31415   if (glyph < it->glyph_row->glyphs[area + 1])
 31416     {
 31417       /* If the glyph row is reversed, we need to prepend the glyph
 31418          rather than append it.  */
 31419       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31420         {
 31421           struct glyph *g;
 31422 
 31423           /* Make room for the additional glyph.  */
 31424           for (g = glyph - 1; g >= it->glyph_row->glyphs[area]; g--)
 31425             g[1] = *g;
 31426           glyph = it->glyph_row->glyphs[area];
 31427 
 31428           /* Decrease the width of the first glyph of the row that
 31429              begins before first_visible_x (e.g., due to hscroll).
 31430              This is so the overall width of the row becomes smaller
 31431              by the scroll amount, and the stretch glyph appended by
 31432              extend_face_to_end_of_line will be wider, to shift the
 31433              row glyphs to the right.  (In L2R rows, the corresponding
 31434              left-shift effect is accomplished by setting row->x to a
 31435              negative value, which won't work with R2L rows.)
 31436 
 31437              This must leave us with a positive value of WIDTH, since
 31438              otherwise the call to move_it_in_display_line_to at the
 31439              beginning of display_line would have got past the entire
 31440              first glyph, and then it->current_x would have been
 31441              greater or equal to it->first_visible_x.  */
 31442           if (it->current_x < it->first_visible_x)
 31443             width -= it->first_visible_x - it->current_x;
 31444           eassert (width > 0);
 31445         }
 31446       glyph->charpos = CHARPOS (it->position);
 31447       glyph->object = object;
 31448       /* FIXME: It would be better to use TYPE_MAX here, but
 31449          __typeof__ is not portable enough...  */
 31450       glyph->pixel_width = clip_to_bounds (-1, width, SHRT_MAX);
 31451       glyph->ascent = ascent;
 31452       glyph->descent = height - ascent;
 31453       glyph->voffset = it->voffset;
 31454       glyph->type = STRETCH_GLYPH;
 31455       glyph->avoid_cursor_p = it->avoid_cursor_p;
 31456       glyph->multibyte_p = it->multibyte_p;
 31457       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31458         {
 31459           /* In R2L rows, the left and the right box edges need to be
 31460              drawn in reverse direction.  */
 31461           glyph->right_box_line_p = it->start_of_box_run_p;
 31462           glyph->left_box_line_p = it->end_of_box_run_p;
 31463         }
 31464       else
 31465         {
 31466           glyph->left_box_line_p = it->start_of_box_run_p;
 31467           glyph->right_box_line_p = it->end_of_box_run_p;
 31468         }
 31469       glyph->overlaps_vertically_p = false;
 31470       glyph->padding_p = false;
 31471       glyph->glyph_not_available_p = false;
 31472       glyph->face_id = it->face_id;
 31473       glyph->u.stretch.ascent = ascent;
 31474       glyph->u.stretch.height = height;
 31475       glyph->slice.img = null_glyph_slice;
 31476       glyph->font_type = FONT_TYPE_UNKNOWN;
 31477       if (it->bidi_p)
 31478         {
 31479           glyph->resolved_level = it->bidi_it.resolved_level;
 31480           eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 31481           glyph->bidi_type = it->bidi_it.type;
 31482         }
 31483       else
 31484         {
 31485           glyph->resolved_level = 0;
 31486           glyph->bidi_type = UNKNOWN_BT;
 31487         }
 31488       ++it->glyph_row->used[area];
 31489     }
 31490   else
 31491     IT_EXPAND_MATRIX_WIDTH (it, area);
 31492 }
 31493 
 31494 #endif  /* HAVE_WINDOW_SYSTEM */
 31495 
 31496 /* Produce a stretch glyph for iterator IT.  IT->object is the value
 31497    of the display property.  The value must be a list of the form
 31498    `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
 31499    being recognized:
 31500 
 31501    1. `:width WIDTH' specifies that the space should be WIDTH *
 31502    canonical char width wide.  WIDTH may be an integer or floating
 31503    point number.
 31504 
 31505    2. `:relative-width FACTOR' specifies that the width of the stretch
 31506    should be computed from the width of the first character having the
 31507    `display' property, and should be FACTOR times that width.
 31508 
 31509    3. `:align-to HPOS' specifies that the space should be wide enough
 31510    to reach HPOS, a value in canonical character units.
 31511 
 31512    Exactly one of the above pairs must be present.
 31513 
 31514    4. `:height HEIGHT' specifies that the height of the stretch produced
 31515    should be HEIGHT, measured in canonical character units.
 31516 
 31517    5. `:relative-height FACTOR' specifies that the height of the
 31518    stretch should be FACTOR times the height of the characters having
 31519    the display property.
 31520 
 31521    Either none or exactly one of 4 or 5 must be present.
 31522 
 31523    6. `:ascent ASCENT'  specifies that ASCENT percent of the height
 31524    of the stretch should be used for the ascent of the stretch.
 31525    ASCENT must be in the range 0 <= ASCENT <= 100.  */
 31526 
 31527 void
 31528 produce_stretch_glyph (struct it *it)
 31529 {
 31530   /* (space :width WIDTH :height HEIGHT ...)  */
 31531   Lisp_Object prop, plist;
 31532   int width = 0, height = 0, align_to = -1;
 31533   bool zero_width_ok_p = false;
 31534   double tem;
 31535   struct font *font = NULL;
 31536 
 31537 #ifdef HAVE_WINDOW_SYSTEM
 31538   int ascent = 0;
 31539   bool zero_height_ok_p = false;
 31540   struct face *face = NULL;     /* shut up GCC's -Wmaybe-uninitialized */
 31541 
 31542   if (FRAME_WINDOW_P (it->f))
 31543     {
 31544       face = FACE_FROM_ID (it->f, it->face_id);
 31545       font = face->font ? face->font : FRAME_FONT (it->f);
 31546       prepare_face_for_display (it->f, face);
 31547     }
 31548 #endif
 31549 
 31550   /* List should start with `space'.  */
 31551   eassert (CONSP (it->object) && EQ (XCAR (it->object), Qspace));
 31552   plist = XCDR (it->object);
 31553 
 31554   /* Compute the width of the stretch.  */
 31555   if ((prop = plist_get (plist, QCwidth), !NILP (prop))
 31556       && calc_pixel_width_or_height (&tem, it, prop, font, true, NULL))
 31557     {
 31558       /* Absolute width `:width WIDTH' specified and valid.  */
 31559       zero_width_ok_p = true;
 31560       width = (int)tem;
 31561     }
 31562   else if (prop = plist_get (plist, QCrelative_width), NUMVAL (prop) > 0)
 31563     {
 31564       /* Relative width `:relative-width FACTOR' specified and valid.
 31565          Compute the width of the characters having this `display'
 31566          property.  */
 31567       struct it it2;
 31568       Lisp_Object object =
 31569         it->sp > 0 ? it->stack[it->sp - 1].string : it->string;
 31570       unsigned char *p = (STRINGP (object)
 31571                           ? SDATA (object) + IT_STRING_BYTEPOS (*it)
 31572                           : BYTE_POS_ADDR (IT_BYTEPOS (*it)));
 31573       bool multibyte_p =
 31574         STRINGP (object) ? STRING_MULTIBYTE (object) : it->multibyte_p;
 31575 
 31576       it2 = *it;
 31577       if (multibyte_p)
 31578         {
 31579           it2.c = it2.char_to_display = string_char_and_length (p, &it2.len);
 31580 #ifdef HAVE_WINDOW_SYSTEM
 31581           if (FRAME_WINDOW_P (it->f) && ! ASCII_CHAR_P (it2.c))
 31582             it2.face_id = FACE_FOR_CHAR (it->f, face, it2.c,
 31583                                          IT_CHARPOS (*it),
 31584                                          STRINGP (object)? object : Qnil);
 31585 #endif
 31586         }
 31587       else
 31588         {
 31589           it2.c = it2.char_to_display = *p, it2.len = 1;
 31590           if (! ASCII_CHAR_P (it2.c))
 31591             it2.char_to_display = BYTE8_TO_CHAR (it2.c);
 31592         }
 31593 
 31594       it2.glyph_row = NULL;
 31595       it2.what = IT_CHARACTER;
 31596       PRODUCE_GLYPHS (&it2);
 31597       width = NUMVAL (prop) * it2.pixel_width;
 31598     }
 31599   else if ((prop = plist_get (plist, QCalign_to), !NILP (prop))
 31600            && calc_pixel_width_or_height (&tem, it, prop, font, true,
 31601                                           &align_to))
 31602     {
 31603       int x = it->current_x + it->continuation_lines_width;
 31604       int x0 = x;
 31605       /* Adjust for line numbers, if needed.   */
 31606       if (!NILP (Vdisplay_line_numbers) && it->line_number_produced_p)
 31607         {
 31608           x -= it->lnum_pixel_width;
 31609           /* Restore the original width, if required.  */
 31610           if (x + it->stretch_adjust >= it->first_visible_x)
 31611             x += it->stretch_adjust;
 31612         }
 31613 
 31614       if (it->glyph_row == NULL || !it->glyph_row->mode_line_p)
 31615         align_to = (align_to < 0
 31616                     ? 0
 31617                     : align_to - window_box_left_offset (it->w, TEXT_AREA));
 31618       else if (align_to < 0)
 31619         align_to = window_box_left_offset (it->w, TEXT_AREA);
 31620       width = max (0, (int)tem + align_to - x);
 31621 
 31622       int next_x = x + width;
 31623       if (!NILP (Vdisplay_line_numbers) && it->line_number_produced_p)
 31624         {
 31625           /* If the line is hscrolled, and the stretch starts before
 31626              the first visible pixel, simulate negative row->x.  */
 31627           if (x < it->first_visible_x)
 31628             {
 31629               next_x -= it->first_visible_x - x;
 31630               it->stretch_adjust = it->first_visible_x - x;
 31631             }
 31632           else
 31633             next_x -= it->stretch_adjust;
 31634         }
 31635       width = next_x - x0;
 31636       zero_width_ok_p = true;
 31637     }
 31638   else
 31639     /* Nothing specified -> width defaults to canonical char width.  */
 31640     width = FRAME_COLUMN_WIDTH (it->f);
 31641 
 31642   if (width <= 0 && (width < 0 || !zero_width_ok_p))
 31643     width = 1;
 31644 
 31645 #ifdef HAVE_WINDOW_SYSTEM
 31646   /* Compute height.  */
 31647   if (FRAME_WINDOW_P (it->f))
 31648     {
 31649       int default_height = normal_char_height (font, ' ');
 31650 
 31651       if ((prop = plist_get (plist, QCheight), !NILP (prop))
 31652           && calc_pixel_width_or_height (&tem, it, prop, font, false, NULL))
 31653         {
 31654           height = (int)tem;
 31655           zero_height_ok_p = true;
 31656         }
 31657       else if (prop = plist_get (plist, QCrelative_height),
 31658                NUMVAL (prop) > 0)
 31659         height = default_height * NUMVAL (prop);
 31660       else
 31661         height = default_height;
 31662 
 31663       if (height <= 0 && (height < 0 || !zero_height_ok_p))
 31664         height = 1;
 31665 
 31666       /* Compute percentage of height used for ascent.  If
 31667          `:ascent ASCENT' is present and valid, use that.  Otherwise,
 31668          derive the ascent from the font in use.  */
 31669       if (prop = plist_get (plist, QCascent),
 31670           NUMVAL (prop) > 0 && NUMVAL (prop) <= 100)
 31671         ascent = height * NUMVAL (prop) / 100.0;
 31672       else if (!NILP (prop)
 31673                && calc_pixel_width_or_height (&tem, it, prop, font, false, 0))
 31674         ascent = min (max (0, (int)tem), height);
 31675       else
 31676         ascent = (height * FONT_BASE (font)) / FONT_HEIGHT (font);
 31677     }
 31678   else
 31679 #endif  /* HAVE_WINDOW_SYSTEM */
 31680     height = 1;
 31681 
 31682   if (width > 0
 31683       && it->area == TEXT_AREA && it->line_wrap != TRUNCATE
 31684       && it->current_x + width > it->last_visible_x)
 31685     {
 31686       width = it->last_visible_x - it->current_x;
 31687 #ifdef HAVE_WINDOW_SYSTEM
 31688       /* Subtract one more pixel from the stretch width, but only on
 31689          GUI frames, since on a TTY each glyph is one "pixel" wide.  */
 31690       width -= FRAME_WINDOW_P (it->f);
 31691 #endif
 31692     }
 31693 
 31694   if (width > 0 && height > 0 && it->glyph_row)
 31695     {
 31696       Lisp_Object o_object = it->object;
 31697       Lisp_Object object =
 31698         it->sp > 0 ? it->stack[it->sp - 1].string : it->string;
 31699       int n = width;
 31700 
 31701       if (!STRINGP (object))
 31702         object = it->w->contents;
 31703 #ifdef HAVE_WINDOW_SYSTEM
 31704       if (FRAME_WINDOW_P (it->f))
 31705         append_stretch_glyph (it, object, width, height, ascent);
 31706       else
 31707 #endif
 31708         {
 31709           it->object = object;
 31710           it->char_to_display = ' ';
 31711           it->pixel_width = it->len = 1;
 31712           while (n--)
 31713             tty_append_glyph (it);
 31714           it->object = o_object;
 31715         }
 31716     }
 31717 
 31718   it->pixel_width = width;
 31719 #ifdef HAVE_WINDOW_SYSTEM
 31720   if (FRAME_WINDOW_P (it->f))
 31721     {
 31722       it->ascent = it->phys_ascent = ascent;
 31723       it->descent = it->phys_descent = height - it->ascent;
 31724       it->nglyphs = width > 0 && height > 0;
 31725       take_vertical_position_into_account (it);
 31726     }
 31727   else
 31728 #endif
 31729     it->nglyphs = width;
 31730 }
 31731 
 31732 /* Get information about special display element WHAT in an
 31733    environment described by IT.  WHAT is one of IT_TRUNCATION or
 31734    IT_CONTINUATION.  Maybe produce glyphs for WHAT if IT has a
 31735    non-null glyph_row member.  This function ensures that fields like
 31736    face_id, c, len of IT are left untouched.  */
 31737 
 31738 static void
 31739 produce_special_glyphs (struct it *it, enum display_element_type what)
 31740 {
 31741   struct it temp_it;
 31742   Lisp_Object gc;
 31743   GLYPH glyph;
 31744 
 31745   temp_it = *it;
 31746   temp_it.object = Qnil;
 31747   memset (&temp_it.current, 0, sizeof temp_it.current);
 31748 
 31749   if (what == IT_CONTINUATION)
 31750     {
 31751       /* Continuation glyph.  For R2L lines, we mirror it by hand.  */
 31752       if (it->bidi_it.paragraph_dir == R2L)
 31753         SET_GLYPH_FROM_CHAR (glyph, '/');
 31754       else
 31755         SET_GLYPH_FROM_CHAR (glyph, '\\');
 31756       if (it->dp
 31757           && (gc = DISP_CONTINUE_GLYPH (it->dp), GLYPH_CODE_P (gc)))
 31758         {
 31759           /* FIXME: Should we mirror GC for R2L lines?  */
 31760           SET_GLYPH_FROM_GLYPH_CODE (glyph, gc);
 31761           spec_glyph_lookup_face (XWINDOW (it->window), &glyph);
 31762         }
 31763     }
 31764   else if (what == IT_TRUNCATION)
 31765     {
 31766       /* Truncation glyph.  */
 31767       SET_GLYPH_FROM_CHAR (glyph, '$');
 31768       if (it->dp
 31769           && (gc = DISP_TRUNC_GLYPH (it->dp), GLYPH_CODE_P (gc)))
 31770         {
 31771           /* FIXME: Should we mirror GC for R2L lines?  */
 31772           SET_GLYPH_FROM_GLYPH_CODE (glyph, gc);
 31773           spec_glyph_lookup_face (XWINDOW (it->window), &glyph);
 31774         }
 31775     }
 31776   else
 31777     emacs_abort ();
 31778 
 31779 #ifdef HAVE_WINDOW_SYSTEM
 31780   /* On a GUI frame, when the right fringe (left fringe for R2L rows)
 31781      is turned off, we precede the truncation/continuation glyphs by a
 31782      stretch glyph whose width is computed such that these special
 31783      glyphs are aligned at the window margin, even when very different
 31784      fonts are used in different glyph rows.  */
 31785   if (FRAME_WINDOW_P (temp_it.f)
 31786       /* init_iterator calls this with it->glyph_row == NULL, and it
 31787          wants only the pixel width of the truncation/continuation
 31788          glyphs.  */
 31789       && temp_it.glyph_row
 31790       /* insert_left_trunc_glyphs calls us at the beginning of the
 31791          row, and it has its own calculation of the stretch glyph
 31792          width.  */
 31793       && temp_it.glyph_row->used[TEXT_AREA] > 0
 31794       && (temp_it.glyph_row->reversed_p
 31795           ? WINDOW_LEFT_FRINGE_WIDTH (temp_it.w)
 31796           : WINDOW_RIGHT_FRINGE_WIDTH (temp_it.w)) == 0)
 31797     {
 31798       int stretch_width = temp_it.last_visible_x - temp_it.current_x;
 31799 
 31800       if (stretch_width > 0)
 31801         {
 31802           struct face *face = FACE_FROM_ID (temp_it.f, temp_it.face_id);
 31803           struct font *font =
 31804             face->font ? face->font : FRAME_FONT (temp_it.f);
 31805           int stretch_ascent =
 31806             (((temp_it.ascent + temp_it.descent)
 31807               * FONT_BASE (font)) / FONT_HEIGHT (font));
 31808 
 31809           append_stretch_glyph (&temp_it, Qnil, stretch_width,
 31810                                 temp_it.ascent + temp_it.descent,
 31811                                 stretch_ascent);
 31812         }
 31813     }
 31814 #endif
 31815 
 31816   temp_it.dp = NULL;
 31817   temp_it.what = IT_CHARACTER;
 31818   temp_it.c = temp_it.char_to_display = GLYPH_CHAR (glyph);
 31819   temp_it.face_id = GLYPH_FACE (glyph);
 31820   temp_it.len = CHAR_BYTES (temp_it.c);
 31821 
 31822   PRODUCE_GLYPHS (&temp_it);
 31823   it->pixel_width = temp_it.pixel_width;
 31824   it->nglyphs = temp_it.nglyphs;
 31825 }
 31826 
 31827 /* Produce padding glyphs for mode/header/tab-line whose text needs to
 31828    be truncated.  This is used when the last visible character leaves
 31829    one or more columns till the window edge, but the next character is
 31830    wider than that number of columns, and therefore cannot fit on the
 31831    line.  We then replace these columns with the appropriate padding
 31832    character: '-' for the mode line and SPC for the other two.  That's
 31833    because these lines should not show the usual truncation glyphs
 31834    there.  This function is only used on TTY frames.  */
 31835 static void
 31836 pad_mode_line (struct it *it, bool mode_line_p)
 31837 {
 31838   struct it temp_it;
 31839   GLYPH glyph;
 31840 
 31841   eassert (!FRAME_WINDOW_P (it->f));
 31842   temp_it = *it;
 31843   temp_it.object = Qnil;
 31844   memset (&temp_it.current, 0, sizeof temp_it.current);
 31845 
 31846   SET_GLYPH (glyph, mode_line_p ? '-' : ' ', it->base_face_id);
 31847 
 31848   temp_it.dp = NULL;
 31849   temp_it.what = IT_CHARACTER;
 31850   temp_it.c = temp_it.char_to_display = GLYPH_CHAR (glyph);
 31851   temp_it.face_id = GLYPH_FACE (glyph);
 31852   temp_it.len = CHAR_BYTES (temp_it.c);
 31853 
 31854   PRODUCE_GLYPHS (&temp_it);
 31855   it->pixel_width = temp_it.pixel_width;
 31856   it->nglyphs = temp_it.nglyphs;
 31857 }
 31858 
 31859 #ifdef HAVE_WINDOW_SYSTEM
 31860 
 31861 /* Calculate line-height and line-spacing properties.
 31862    An integer value specifies explicit pixel value.
 31863    A float value specifies relative value to current face height.
 31864    A cons (float . face-name) specifies relative value to
 31865    height of specified face font.
 31866 
 31867    Returns height in pixels, or nil.  */
 31868 
 31869 static Lisp_Object
 31870 calc_line_height_property (struct it *it, Lisp_Object val, struct font *font,
 31871                            int boff, bool override)
 31872 {
 31873   Lisp_Object face_name = Qnil;
 31874   int ascent, descent, height;
 31875 
 31876   if (NILP (val) || INTEGERP (val) || (override && EQ (val, Qt)))
 31877     return val;
 31878 
 31879   if (CONSP (val))
 31880     {
 31881       face_name = XCAR (val);
 31882       val = XCDR (val);
 31883       if (!NUMBERP (val))
 31884         val = make_fixnum (1);
 31885       if (NILP (face_name))
 31886         {
 31887           height = it->ascent + it->descent;
 31888           goto scale;
 31889         }
 31890     }
 31891 
 31892   if (NILP (face_name))
 31893     {
 31894       font = FRAME_FONT (it->f);
 31895       boff = FRAME_BASELINE_OFFSET (it->f);
 31896     }
 31897   else if (EQ (face_name, Qt))
 31898     {
 31899       override = false;
 31900     }
 31901   else
 31902     {
 31903       int face_id;
 31904       struct face *face;
 31905 
 31906       face_id = lookup_named_face (it->w, it->f, face_name, false);
 31907       face = FACE_FROM_ID_OR_NULL (it->f, face_id);
 31908       if (face == NULL || ((font = face->font) == NULL))
 31909         return make_fixnum (-1);
 31910       boff = font->baseline_offset;
 31911       if (font->vertical_centering)
 31912         boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
 31913     }
 31914 
 31915   normal_char_ascent_descent (font, -1, &ascent, &descent);
 31916 
 31917   if (override)
 31918     {
 31919       it->override_ascent = ascent;
 31920       it->override_descent = descent;
 31921       it->override_boff = boff;
 31922     }
 31923 
 31924   height = ascent + descent;
 31925 
 31926  scale:
 31927   /* FIXME: Check for overflow in multiplication or conversion.  */
 31928   if (FLOATP (val))
 31929     height = (int)(XFLOAT_DATA (val) * height);
 31930   else if (INTEGERP (val))
 31931     {
 31932       intmax_t v;
 31933       if (integer_to_intmax (val, &v))
 31934         height *= v;
 31935     }
 31936 
 31937   return make_fixnum (height);
 31938 }
 31939 
 31940 
 31941 /* Append a glyph for a glyphless character to IT->glyph_row.  FACE_ID
 31942    is a face ID to be used for the glyph.  FOR_NO_FONT is true if
 31943    and only if this is for a character for which no font was found.
 31944 
 31945    If the display method (it->glyphless_method) is
 31946    GLYPHLESS_DISPLAY_ACRONYM or GLYPHLESS_DISPLAY_HEX_CODE, LEN is a
 31947    length of the acronym or the hexadecimal string, UPPER_XOFF and
 31948    UPPER_YOFF are pixel offsets for the upper part of the string,
 31949    LOWER_XOFF and LOWER_YOFF are for the lower part.
 31950 
 31951    For the other display methods, LEN through LOWER_YOFF are zero.  */
 31952 
 31953 static void
 31954 append_glyphless_glyph (struct it *it, int face_id, bool for_no_font, int len,
 31955                         short upper_xoff, short upper_yoff,
 31956                         short lower_xoff, short lower_yoff)
 31957 {
 31958   struct glyph *glyph;
 31959   enum glyph_row_area area = it->area;
 31960 
 31961   glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 31962   if (glyph < it->glyph_row->glyphs[area + 1])
 31963     {
 31964       /* If the glyph row is reversed, we need to prepend the glyph
 31965          rather than append it.  */
 31966       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31967         {
 31968           struct glyph *g;
 31969 
 31970           /* Make room for the additional glyph.  */
 31971           for (g = glyph - 1; g >= it->glyph_row->glyphs[area]; g--)
 31972             g[1] = *g;
 31973           glyph = it->glyph_row->glyphs[area];
 31974         }
 31975       glyph->charpos = CHARPOS (it->position);
 31976       glyph->object = it->object;
 31977       eassert (it->pixel_width <= SHRT_MAX);
 31978       glyph->pixel_width = it->pixel_width;
 31979       glyph->ascent = it->ascent;
 31980       glyph->descent = it->descent;
 31981       glyph->voffset = it->voffset;
 31982       glyph->type = GLYPHLESS_GLYPH;
 31983       glyph->u.glyphless.method = it->glyphless_method;
 31984       glyph->u.glyphless.for_no_font = for_no_font;
 31985       glyph->u.glyphless.len = len;
 31986       glyph->u.glyphless.ch = it->c;
 31987       glyph->slice.glyphless.upper_xoff = upper_xoff;
 31988       glyph->slice.glyphless.upper_yoff = upper_yoff;
 31989       glyph->slice.glyphless.lower_xoff = lower_xoff;
 31990       glyph->slice.glyphless.lower_yoff = lower_yoff;
 31991       glyph->avoid_cursor_p = it->avoid_cursor_p;
 31992       glyph->multibyte_p = it->multibyte_p;
 31993       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31994         {
 31995           /* In R2L rows, the left and the right box edges need to be
 31996              drawn in reverse direction.  */
 31997           glyph->right_box_line_p = it->start_of_box_run_p;
 31998           glyph->left_box_line_p = it->end_of_box_run_p;
 31999         }
 32000       else
 32001         {
 32002           glyph->left_box_line_p = it->start_of_box_run_p;
 32003           glyph->right_box_line_p = it->end_of_box_run_p;
 32004         }
 32005       glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
 32006                                       || it->phys_descent > it->descent);
 32007       glyph->padding_p = false;
 32008       glyph->glyph_not_available_p = false;
 32009       glyph->face_id = face_id;
 32010       glyph->font_type = FONT_TYPE_UNKNOWN;
 32011       if (it->bidi_p)
 32012         {
 32013           glyph->resolved_level = it->bidi_it.resolved_level;
 32014           eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 32015           glyph->bidi_type = it->bidi_it.type;
 32016         }
 32017       ++it->glyph_row->used[area];
 32018     }
 32019   else
 32020     IT_EXPAND_MATRIX_WIDTH (it, area);
 32021 }
 32022 
 32023 
 32024 /* Produce a glyph for a glyphless character for iterator IT.
 32025    IT->glyphless_method specifies which method to use for displaying
 32026    the character.  See the description of enum
 32027    glyphless_display_method in dispextern.h for the detail.
 32028 
 32029    FOR_NO_FONT is true if and only if this is for a character for
 32030    which no font was found.  ACRONYM, if non-nil, is an acronym string
 32031    for the character.  */
 32032 
 32033 static void
 32034 produce_glyphless_glyph (struct it *it, bool for_no_font, Lisp_Object acronym)
 32035 {
 32036   int face_id;
 32037   struct face *face;
 32038   struct font *font;
 32039   int base_width, base_height, width, height;
 32040   short upper_xoff, upper_yoff, lower_xoff, lower_yoff;
 32041   int len;
 32042 
 32043   /* Get the metrics of the base font.  We always refer to the current
 32044      ASCII face.  */
 32045   face = FACE_FROM_ID (it->f, it->face_id)->ascii_face;
 32046   font = face->font ? face->font : FRAME_FONT (it->f);
 32047   normal_char_ascent_descent (font, -1, &it->ascent, &it->descent);
 32048   it->ascent += font->baseline_offset;
 32049   it->descent -= font->baseline_offset;
 32050   base_height = it->ascent + it->descent;
 32051   base_width = font->average_width;
 32052 
 32053   face_id = merge_glyphless_glyph_face (it);
 32054 
 32055   if (it->glyphless_method == GLYPHLESS_DISPLAY_THIN_SPACE)
 32056     {
 32057       it->pixel_width = THIN_SPACE_WIDTH;
 32058       len = 0;
 32059       upper_xoff = upper_yoff = lower_xoff = lower_yoff = 0;
 32060     }
 32061   else if (it->glyphless_method == GLYPHLESS_DISPLAY_EMPTY_BOX)
 32062     {
 32063       width = CHARACTER_WIDTH (it->c);
 32064       if (width == 0)
 32065         width = 1;
 32066       else if (width > 4)
 32067         width = 4;
 32068       it->pixel_width = base_width * width;
 32069       len = 0;
 32070       upper_xoff = upper_yoff = lower_xoff = lower_yoff = 0;
 32071     }
 32072   else
 32073     {
 32074       char buf[7];
 32075       const char *str;
 32076       unsigned int code[6];
 32077       int upper_len;
 32078       int ascent, descent;
 32079       struct font_metrics metrics_upper, metrics_lower;
 32080 
 32081       face = FACE_FROM_ID (it->f, face_id);
 32082       font = face->font ? face->font : FRAME_FONT (it->f);
 32083       prepare_face_for_display (it->f, face);
 32084 
 32085       if (it->glyphless_method == GLYPHLESS_DISPLAY_ACRONYM)
 32086         {
 32087           if (! STRINGP (acronym) && CHAR_TABLE_P (Vglyphless_char_display))
 32088             acronym = CHAR_TABLE_REF (Vglyphless_char_display, it->c);
 32089           if (CONSP (acronym))
 32090             acronym = XCAR (acronym);
 32091           str = STRINGP (acronym) ? SSDATA (acronym) : "";
 32092         }
 32093       else
 32094         {
 32095           eassert (it->glyphless_method == GLYPHLESS_DISPLAY_HEX_CODE);
 32096           sprintf (buf, "%0*X", it->c < 0x10000 ? 4 : 6, it->c + 0u);
 32097           str = buf;
 32098         }
 32099       for (len = 0; str[len] && ASCII_CHAR_P (str[len]) && len < 6; len++)
 32100         code[len] = font->driver->encode_char (font, str[len]);
 32101       upper_len = (len + 1) / 2;
 32102       font->driver->text_extents (font, code, upper_len,
 32103                                   &metrics_upper);
 32104       font->driver->text_extents (font, code + upper_len, len - upper_len,
 32105                                   &metrics_lower);
 32106 
 32107 
 32108 
 32109       /* +4 is for vertical bars of a box plus 1-pixel spaces at both side.  */
 32110       width = max (metrics_upper.width, metrics_lower.width) + 4;
 32111       upper_xoff = lower_xoff = 2; /* the typical case */
 32112       if (base_width >= width)
 32113         {
 32114           /* Align the upper to the left, the lower to the right.  */
 32115           it->pixel_width = base_width;
 32116           lower_xoff = base_width - 2 - metrics_lower.width;
 32117         }
 32118       else
 32119         {
 32120           /* Center the shorter one.  */
 32121           it->pixel_width = width;
 32122           if (metrics_upper.width >= metrics_lower.width)
 32123             lower_xoff = (width - metrics_lower.width) / 2;
 32124           else
 32125             upper_xoff = (width - metrics_upper.width) / 2;
 32126         }
 32127 
 32128       /* +5 is for horizontal bars of a box plus 1-pixel spaces at
 32129          top, bottom, and between upper and lower strings.  */
 32130       height = (metrics_upper.ascent + metrics_upper.descent
 32131                 + metrics_lower.ascent + metrics_lower.descent) + 5;
 32132       /* Center vertically.
 32133          H:base_height, D:base_descent
 32134          h:height, ld:lower_descent, la:lower_ascent, ud:upper_descent
 32135 
 32136          ascent = - (D - H/2 - h/2 + 1); "+ 1" for rounding up
 32137          descent = D - H/2 + h/2;
 32138          lower_yoff = descent - 2 - ld;
 32139          upper_yoff = lower_yoff - la - 1 - ud;  */
 32140       ascent = - (it->descent - (base_height + height + 1) / 2);
 32141       descent = it->descent - (base_height - height) / 2;
 32142       lower_yoff = descent - 2 - metrics_lower.descent;
 32143       upper_yoff = (lower_yoff - metrics_lower.ascent - 1
 32144                     - metrics_upper.descent);
 32145       /* Don't make the height shorter than the base height.  */
 32146       if (height > base_height)
 32147         {
 32148           it->ascent = ascent;
 32149           it->descent = descent;
 32150         }
 32151     }
 32152 
 32153   it->phys_ascent = it->ascent;
 32154   it->phys_descent = it->descent;
 32155   if (it->glyph_row)
 32156     append_glyphless_glyph (it, face_id, for_no_font, len,
 32157                             upper_xoff, upper_yoff,
 32158                             lower_xoff, lower_yoff);
 32159   it->nglyphs = 1;
 32160   take_vertical_position_into_account (it);
 32161 }
 32162 
 32163 
 32164 /* If face has a box, add the box thickness to the character
 32165    height.  If character has a box line to the left and/or
 32166    right, add the box line width to the character's width.  */
 32167 #define IT_APPLY_FACE_BOX(it, face)                             \
 32168   do {                                                          \
 32169     if (face->box != FACE_NO_BOX)                               \
 32170       {                                                         \
 32171         int thick = face->box_horizontal_line_width;            \
 32172         if (thick > 0)                                          \
 32173           {                                                     \
 32174             it->ascent += thick;                                \
 32175             it->descent += thick;                               \
 32176           }                                                     \
 32177                                                                 \
 32178         thick = face->box_vertical_line_width;                  \
 32179         if (thick > 0)                                          \
 32180           {                                                     \
 32181             if (it->start_of_box_run_p)                         \
 32182               it->pixel_width += thick;                         \
 32183             if (it->end_of_box_run_p)                           \
 32184               it->pixel_width += thick;                         \
 32185           }                                                     \
 32186       }                                                         \
 32187     } while (false)
 32188 
 32189 /* RIF:
 32190    Produce glyphs/get display metrics for the display element IT is
 32191    loaded with.  See the description of struct it in dispextern.h
 32192    for an overview of struct it.  */
 32193 
 32194 void
 32195 gui_produce_glyphs (struct it *it)
 32196 {
 32197   int extra_line_spacing = it->extra_line_spacing;
 32198 
 32199   it->glyph_not_available_p = false;
 32200 
 32201   if (it->what == IT_CHARACTER)
 32202     {
 32203       unsigned char2b;
 32204       struct face *face = FACE_FROM_ID (it->f, it->face_id);
 32205       struct font *font = face->font;
 32206       struct font_metrics *pcm = NULL;
 32207       int boff;                 /* Baseline offset.  */
 32208 
 32209       if (font == NULL)
 32210         {
 32211           /* When no suitable font is found, display this character by
 32212              the method specified in the first extra slot of
 32213              Vglyphless_char_display.  */
 32214           Lisp_Object acronym = lookup_glyphless_char_display (-1, it);
 32215 
 32216           eassert (it->what == IT_GLYPHLESS);
 32217           produce_glyphless_glyph (it, true,
 32218                                    STRINGP (acronym) ? acronym : Qnil);
 32219           goto done;
 32220         }
 32221 
 32222       boff = font->baseline_offset;
 32223       if (font->vertical_centering)
 32224         boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
 32225 
 32226       if (it->char_to_display != '\n' && it->char_to_display != '\t')
 32227         {
 32228           it->nglyphs = 1;
 32229 
 32230           if (it->override_ascent >= 0)
 32231             {
 32232               it->ascent = it->override_ascent;
 32233               it->descent = it->override_descent;
 32234               boff = it->override_boff;
 32235             }
 32236           else
 32237             {
 32238               it->ascent = FONT_BASE (font) + boff;
 32239               it->descent = FONT_DESCENT (font) - boff;
 32240             }
 32241 
 32242           if (get_char_glyph_code (it->char_to_display, font, &char2b))
 32243             {
 32244               pcm = get_per_char_metric (font, &char2b);
 32245               if (pcm->width == 0
 32246                   && pcm->rbearing == 0 && pcm->lbearing == 0)
 32247                 pcm = NULL;
 32248             }
 32249 
 32250           if (pcm)
 32251             {
 32252               it->phys_ascent = pcm->ascent + boff;
 32253               it->phys_descent = pcm->descent - boff;
 32254               it->pixel_width = pcm->width;
 32255               /* Don't use font-global values for ascent and descent
 32256                  if they result in an exceedingly large line height.  */
 32257               if (it->override_ascent < 0)
 32258                 {
 32259                   if (FONT_TOO_HIGH (font))
 32260                     {
 32261                       it->ascent = it->phys_ascent;
 32262                       it->descent = it->phys_descent;
 32263                       /* These limitations are enforced by an
 32264                          assertion near the end of this function.  */
 32265                       if (it->ascent < 0)
 32266                         it->ascent = 0;
 32267                       if (it->descent < 0)
 32268                         it->descent = 0;
 32269                     }
 32270                 }
 32271             }
 32272           else
 32273             {
 32274               it->glyph_not_available_p = true;
 32275               it->phys_ascent = it->ascent;
 32276               it->phys_descent = it->descent;
 32277               it->pixel_width = font->space_width;
 32278             }
 32279 
 32280           if (it->constrain_row_ascent_descent_p)
 32281             {
 32282               if (it->descent > it->max_descent)
 32283                 {
 32284                   it->ascent += it->descent - it->max_descent;
 32285                   it->descent = it->max_descent;
 32286                 }
 32287               if (it->ascent > it->max_ascent)
 32288                 {
 32289                   it->descent = min (it->max_descent, it->descent + it->ascent - it->max_ascent);
 32290                   it->ascent = it->max_ascent;
 32291                 }
 32292               it->phys_ascent = min (it->phys_ascent, it->ascent);
 32293               it->phys_descent = min (it->phys_descent, it->descent);
 32294               extra_line_spacing = 0;
 32295             }
 32296 
 32297           /* If this is a space inside a region of text with
 32298              `space-width' property, change its width.  */
 32299           bool stretched_p
 32300             = it->char_to_display == ' ' && !NILP (it->space_width);
 32301           if (stretched_p)
 32302             it->pixel_width *= XFLOATINT (it->space_width);
 32303 
 32304           IT_APPLY_FACE_BOX(it, face);
 32305 
 32306           /* If face has an overline, add the height of the overline
 32307              (1 pixel) and a 1 pixel margin to the character height.  */
 32308           if (face->overline_p)
 32309             it->ascent += clip_to_bounds (0, overline_margin, 1000000);
 32310 
 32311           if (it->constrain_row_ascent_descent_p)
 32312             {
 32313               if (it->ascent > it->max_ascent)
 32314                 it->ascent = it->max_ascent;
 32315               if (it->descent > it->max_descent)
 32316                 it->descent = it->max_descent;
 32317             }
 32318 
 32319           take_vertical_position_into_account (it);
 32320 
 32321           /* If we have to actually produce glyphs, do it.  */
 32322           if (it->glyph_row)
 32323             {
 32324               if (stretched_p)
 32325                 {
 32326                   /* Translate a space with a `space-width' property
 32327                      into a stretch glyph.  */
 32328                   int ascent = (((it->ascent + it->descent) * FONT_BASE (font))
 32329                                 / FONT_HEIGHT (font));
 32330                   append_stretch_glyph (it, it->object, it->pixel_width,
 32331                                         it->ascent + it->descent, ascent);
 32332                 }
 32333               else
 32334                 append_glyph (it);
 32335 
 32336               /* If characters with lbearing or rbearing are displayed
 32337                  in this line, record that fact in a flag of the
 32338                  glyph row.  This is used to optimize X output code.  */
 32339               if (pcm && (pcm->lbearing < 0 || pcm->rbearing > pcm->width))
 32340                 it->glyph_row->contains_overlapping_glyphs_p = true;
 32341             }
 32342           if (! stretched_p && it->pixel_width == 0)
 32343             /* We assure that all visible glyphs have at least 1-pixel
 32344                width.  */
 32345             it->pixel_width = 1;
 32346         }
 32347       else if (it->char_to_display == '\n')
 32348         {
 32349           /* A newline has no width, but we need the height of the
 32350              line.  But if previous part of the line sets a height,
 32351              don't increase that height.  */
 32352 
 32353           Lisp_Object height;
 32354           Lisp_Object total_height = Qnil;
 32355 
 32356           it->override_ascent = -1;
 32357           it->pixel_width = 0;
 32358           it->nglyphs = 0;
 32359 
 32360           height = get_it_property (it, Qline_height);
 32361           /* Split (line-height total-height) list.  */
 32362           if (CONSP (height)
 32363               && CONSP (XCDR (height))
 32364               && NILP (XCDR (XCDR (height))))
 32365             {
 32366               total_height = XCAR (XCDR (height));
 32367               height = XCAR (height);
 32368             }
 32369           height = calc_line_height_property (it, height, font, boff, true);
 32370 
 32371           if (it->override_ascent >= 0)
 32372             {
 32373               it->ascent = it->override_ascent;
 32374               it->descent = it->override_descent;
 32375               boff = it->override_boff;
 32376             }
 32377           else
 32378             {
 32379               if (FONT_TOO_HIGH (font))
 32380                 {
 32381                   it->ascent = font->pixel_size + boff - 1;
 32382                   it->descent = -boff + 1;
 32383                   if (it->descent < 0)
 32384                     it->descent = 0;
 32385                 }
 32386               else
 32387                 {
 32388                   it->ascent = FONT_BASE (font) + boff;
 32389                   it->descent = FONT_DESCENT (font) - boff;
 32390                 }
 32391             }
 32392 
 32393           if (EQ (height, Qt))
 32394             {
 32395               if (it->descent > it->max_descent)
 32396                 {
 32397                   it->ascent += it->descent - it->max_descent;
 32398                   it->descent = it->max_descent;
 32399                 }
 32400               if (it->ascent > it->max_ascent)
 32401                 {
 32402                   it->descent = min (it->max_descent, it->descent + it->ascent - it->max_ascent);
 32403                   it->ascent = it->max_ascent;
 32404                 }
 32405               it->phys_ascent = min (it->phys_ascent, it->ascent);
 32406               it->phys_descent = min (it->phys_descent, it->descent);
 32407               it->constrain_row_ascent_descent_p = true;
 32408               extra_line_spacing = 0;
 32409             }
 32410           else
 32411             {
 32412               Lisp_Object spacing;
 32413 
 32414               it->phys_ascent = it->ascent;
 32415               it->phys_descent = it->descent;
 32416 
 32417               if ((it->max_ascent > 0 || it->max_descent > 0)
 32418                   && face->box != FACE_NO_BOX
 32419                   && face->box_horizontal_line_width > 0)
 32420                 {
 32421                   it->ascent += face->box_horizontal_line_width;
 32422                   it->descent += face->box_horizontal_line_width;
 32423                 }
 32424               if (!NILP (height)
 32425                   && XFIXNUM (height) > it->ascent + it->descent)
 32426                 it->ascent = XFIXNUM (height) - it->descent;
 32427 
 32428               if (!NILP (total_height))
 32429                 spacing = calc_line_height_property (it, total_height, font,
 32430                                                      boff, false);
 32431               else
 32432                 {
 32433                   spacing = get_it_property (it, Qline_spacing);
 32434                   spacing = calc_line_height_property (it, spacing, font,
 32435                                                        boff, false);
 32436                 }
 32437               if (FIXNUMP (spacing))
 32438                 {
 32439                   extra_line_spacing = XFIXNUM (spacing);
 32440                   if (!NILP (total_height))
 32441                     extra_line_spacing -= (it->phys_ascent + it->phys_descent);
 32442                 }
 32443             }
 32444         }
 32445       else                    /* i.e. (it->char_to_display == '\t') */
 32446         {
 32447           if (font->space_width > 0)
 32448             {
 32449               int tab_width = it->tab_width * font->space_width;
 32450               int x = it->current_x + it->continuation_lines_width;
 32451               int x0 = x;
 32452               /* Adjust for line numbers, if needed.   */
 32453               if (!NILP (Vdisplay_line_numbers) && it->line_number_produced_p)
 32454                 {
 32455                   x -= it->lnum_pixel_width;
 32456                   /* Restore the original TAB width, if required.  */
 32457                   if (x + it->stretch_adjust >= it->first_visible_x)
 32458                     x += it->stretch_adjust;
 32459                 }
 32460 
 32461               int next_tab_x = ((1 + x + tab_width - 1) / tab_width) * tab_width;
 32462 
 32463               /* If the distance from the current position to the next tab
 32464                  stop is less than a space character width, use the
 32465                  tab stop after that.  */
 32466               if (next_tab_x - x < font->space_width)
 32467                 next_tab_x += tab_width;
 32468               if (!NILP (Vdisplay_line_numbers) && it->line_number_produced_p)
 32469                 {
 32470                   next_tab_x += it->lnum_pixel_width;
 32471                   /* If the line is hscrolled, and the TAB starts before
 32472                      the first visible pixel, simulate negative row->x.  */
 32473                   if (x < it->first_visible_x)
 32474                     {
 32475                       next_tab_x -= it->first_visible_x - x;
 32476                       it->stretch_adjust = it->first_visible_x - x;
 32477                     }
 32478                   else
 32479                     next_tab_x -= it->stretch_adjust;
 32480                 }
 32481 
 32482               it->pixel_width = next_tab_x - x0;
 32483               it->nglyphs = 1;
 32484               if (FONT_TOO_HIGH (font))
 32485                 {
 32486                   if (get_char_glyph_code (' ', font, &char2b))
 32487                     {
 32488                       pcm = get_per_char_metric (font, &char2b);
 32489                       if (pcm->width == 0
 32490                           && pcm->rbearing == 0 && pcm->lbearing == 0)
 32491                         pcm = NULL;
 32492                     }
 32493 
 32494                   if (pcm)
 32495                     {
 32496                       it->ascent = pcm->ascent + boff;
 32497                       it->descent = pcm->descent - boff;
 32498                     }
 32499                   else
 32500                     {
 32501                       it->ascent = font->pixel_size + boff - 1;
 32502                       it->descent = -boff + 1;
 32503                     }
 32504                   if (it->ascent < 0)
 32505                     it->ascent = 0;
 32506                   if (it->descent < 0)
 32507                     it->descent = 0;
 32508                 }
 32509               else
 32510                 {
 32511                   it->ascent = FONT_BASE (font) + boff;
 32512                   it->descent = FONT_DESCENT (font) - boff;
 32513                 }
 32514               it->phys_ascent = it->ascent;
 32515               it->phys_descent = it->descent;
 32516 
 32517               if (it->glyph_row)
 32518                 {
 32519                   append_stretch_glyph (it, it->object, it->pixel_width,
 32520                                         it->ascent + it->descent, it->ascent);
 32521                 }
 32522             }
 32523           else
 32524             {
 32525               it->pixel_width = 0;
 32526               it->nglyphs = 1;
 32527             }
 32528         }
 32529 
 32530       if (FONT_TOO_HIGH (font))
 32531         {
 32532           int font_ascent, font_descent;
 32533 
 32534           /* For very large fonts, where we ignore the declared font
 32535              dimensions, and go by per-character metrics instead,
 32536              don't let the row ascent and descent values (and the row
 32537              height computed from them) be smaller than the "normal"
 32538              character metrics.  This avoids unpleasant effects
 32539              whereby lines on display would change their height
 32540              depending on which characters are shown.  */
 32541           normal_char_ascent_descent (font, -1, &font_ascent, &font_descent);
 32542           it->max_ascent = max (it->max_ascent, font_ascent);
 32543           it->max_descent = max (it->max_descent, font_descent);
 32544         }
 32545 
 32546       if (it->ascent < 0)
 32547         it->ascent = 0;
 32548       if (it->descent < 0)
 32549         it->descent = 0;
 32550     }
 32551   else if (it->what == IT_COMPOSITION && it->cmp_it.ch < 0)
 32552     {
 32553       /* A static composition.
 32554 
 32555          Note: A composition is represented as one glyph in the
 32556          glyph matrix.  There are no padding glyphs.
 32557 
 32558          Important note: pixel_width, ascent, and descent are the
 32559          values of what is drawn by draw_glyphs (i.e. the values of
 32560          the overall glyphs composed).  */
 32561       struct face *face = FACE_FROM_ID (it->f, it->face_id);
 32562       int boff;                 /* baseline offset */
 32563       struct composition *cmp = composition_table[it->cmp_it.id];
 32564       int glyph_len = cmp->glyph_len;
 32565       struct font *font = face->font;
 32566 
 32567       it->nglyphs = 1;
 32568 
 32569       /* If we have not yet calculated pixel size data of glyphs of
 32570          the composition for the current face font, calculate them
 32571          now.  Theoretically, we have to check all fonts for the
 32572          glyphs, but that requires much time and memory space.  So,
 32573          here we check only the font of the first glyph.  This may
 32574          lead to incorrect display, but it's very rare, and C-l
 32575          (recenter-top-bottom) can correct the display anyway.  */
 32576       if (! cmp->font || cmp->font != font)
 32577         {
 32578           /* Ascent and descent of the font of the first character
 32579              of this composition (adjusted by baseline offset).
 32580              Ascent and descent of overall glyphs should not be less
 32581              than these, respectively.  */
 32582           int font_ascent, font_descent, font_height;
 32583           /* Bounding box of the overall glyphs.  */
 32584           int leftmost, rightmost, lowest, highest;
 32585           int lbearing, rbearing;
 32586           int i, width, ascent, descent;
 32587           int c;
 32588           unsigned char2b;
 32589           struct font_metrics *pcm;
 32590           ptrdiff_t pos;
 32591 
 32592           eassume (0 < glyph_len); /* See Bug#8512.  */
 32593           do
 32594             c = COMPOSITION_GLYPH (cmp, glyph_len - 1);
 32595           while (c == '\t' && 0 < --glyph_len);
 32596 
 32597           bool right_padded = glyph_len < cmp->glyph_len;
 32598           for (i = 0; i < glyph_len; i++)
 32599             {
 32600               c = COMPOSITION_GLYPH (cmp, i);
 32601               if (c != '\t')
 32602                 break;
 32603               cmp->offsets[i * 2] = cmp->offsets[i * 2 + 1] = 0;
 32604             }
 32605           bool left_padded = i > 0;
 32606 
 32607           pos = (STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
 32608                  : IT_CHARPOS (*it));
 32609           /* If no suitable font is found, use the default font.  */
 32610           bool font_not_found_p = font == NULL;
 32611           if (font_not_found_p)
 32612             {
 32613               face = face->ascii_face;
 32614               font = face->font;
 32615             }
 32616           boff = font->baseline_offset;
 32617           if (font->vertical_centering)
 32618             boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
 32619           normal_char_ascent_descent (font, -1, &font_ascent, &font_descent);
 32620           font_ascent +=  boff;
 32621           font_descent -= boff;
 32622           font_height = font_ascent + font_descent;
 32623 
 32624           cmp->font = font;
 32625 
 32626           pcm = NULL;
 32627           if (! font_not_found_p)
 32628             {
 32629               get_char_face_and_encoding (it->f, c, it->face_id,
 32630                                           &char2b, false);
 32631               pcm = get_per_char_metric (font, &char2b);
 32632             }
 32633 
 32634           /* Initialize the bounding box.  */
 32635           if (pcm)
 32636             {
 32637               width = cmp->glyph_len > 0 ? pcm->width : 0;
 32638               ascent = pcm->ascent;
 32639               descent = pcm->descent;
 32640               lbearing = pcm->lbearing;
 32641               rbearing = pcm->rbearing;
 32642             }
 32643           else
 32644             {
 32645               width = cmp->glyph_len > 0 ? font->space_width : 0;
 32646               ascent = FONT_BASE (font);
 32647               descent = FONT_DESCENT (font);
 32648               lbearing = 0;
 32649               rbearing = width;
 32650             }
 32651 
 32652           rightmost = width;
 32653           leftmost = 0;
 32654           lowest = - descent + boff;
 32655           highest = ascent + boff;
 32656 
 32657           if (! font_not_found_p
 32658               && font->default_ascent
 32659               && CHAR_TABLE_P (Vuse_default_ascent)
 32660               && !NILP (Faref (Vuse_default_ascent,
 32661                                make_fixnum (it->char_to_display))))
 32662             highest = font->default_ascent + boff;
 32663 
 32664           /* Draw the first glyph at the normal position.  It may be
 32665              shifted to right later if some other glyphs are drawn
 32666              at the left.  */
 32667           cmp->offsets[i * 2] = 0;
 32668           cmp->offsets[i * 2 + 1] = boff;
 32669           cmp->lbearing = lbearing;
 32670           cmp->rbearing = rbearing;
 32671 
 32672           /* Set cmp->offsets for the remaining glyphs.  */
 32673           for (i++; i < glyph_len; i++)
 32674             {
 32675               int left, right, btm, top;
 32676               int ch = COMPOSITION_GLYPH (cmp, i);
 32677               int face_id;
 32678               struct face *this_face;
 32679 
 32680               if (ch == '\t')
 32681                 ch = ' ';
 32682               face_id = FACE_FOR_CHAR (it->f, face, ch, pos, it->string);
 32683               this_face = FACE_FROM_ID (it->f, face_id);
 32684               font = this_face->font;
 32685 
 32686               if (font == NULL)
 32687                 pcm = NULL;
 32688               else
 32689                 {
 32690                   get_char_face_and_encoding (it->f, ch, face_id,
 32691                                               &char2b, false);
 32692                   pcm = get_per_char_metric (font, &char2b);
 32693                 }
 32694               if (! pcm)
 32695                 cmp->offsets[i * 2] = cmp->offsets[i * 2 + 1] = 0;
 32696               else
 32697                 {
 32698                   width = pcm->width;
 32699                   ascent = pcm->ascent;
 32700                   descent = pcm->descent;
 32701                   lbearing = pcm->lbearing;
 32702                   rbearing = pcm->rbearing;
 32703                   if (cmp->method != COMPOSITION_WITH_RULE_ALTCHARS)
 32704                     {
 32705                       /* Relative composition with or without
 32706                          alternate chars.  */
 32707                       left = (leftmost + rightmost - width) / 2;
 32708                       btm = - descent + boff;
 32709                       if (font->relative_compose
 32710                           && (! CHAR_TABLE_P (Vignore_relative_composition)
 32711                               || NILP (Faref (Vignore_relative_composition,
 32712                                               make_fixnum (ch)))))
 32713                         {
 32714 
 32715                           if (- descent >= font->relative_compose)
 32716                             /* One extra pixel between two glyphs.  */
 32717                             btm = highest + 1;
 32718                           else if (ascent <= 0)
 32719                             /* One extra pixel between two glyphs.  */
 32720                             btm = lowest - 1 - ascent - descent;
 32721                         }
 32722                     }
 32723                   else
 32724                     {
 32725                       /* A composition rule is specified by an integer
 32726                          value that encodes global and new reference
 32727                          points (GREF and NREF).  GREF and NREF are
 32728                          specified by numbers as below:
 32729 
 32730                          0---1---2 -- ascent
 32731                          |       |
 32732                          |       |
 32733                          |       |
 32734                          9--10--11 -- center
 32735                          |       |
 32736                          ---3---4---5--- baseline
 32737                          |       |
 32738                          6---7---8 -- descent
 32739                       */
 32740                       int rule = COMPOSITION_RULE (cmp, i);
 32741                       int gref, nref, grefx, grefy, nrefx, nrefy, xoff, yoff;
 32742 
 32743                       COMPOSITION_DECODE_RULE (rule, gref, nref, xoff, yoff);
 32744                       grefx = gref % 3, nrefx = nref % 3;
 32745                       grefy = gref / 3, nrefy = nref / 3;
 32746                       if (xoff)
 32747                         xoff = font_height * (xoff - 128) / 256;
 32748                       if (yoff)
 32749                         yoff = font_height * (yoff - 128) / 256;
 32750 
 32751                       left = (leftmost
 32752                               + grefx * (rightmost - leftmost) / 2
 32753                               - nrefx * width / 2
 32754                               + xoff);
 32755 
 32756                       btm = ((grefy == 0 ? highest
 32757                               : grefy == 1 ? 0
 32758                               : grefy == 2 ? lowest
 32759                               : (highest + lowest) / 2)
 32760                              - (nrefy == 0 ? ascent + descent
 32761                                 : nrefy == 1 ? descent - boff
 32762                                 : nrefy == 2 ? 0
 32763                                 : (ascent + descent) / 2)
 32764                              + yoff);
 32765                     }
 32766 
 32767                   cmp->offsets[i * 2] = left;
 32768                   cmp->offsets[i * 2 + 1] = btm + descent;
 32769 
 32770                   /* Update the bounding box of the overall glyphs. */
 32771                   if (width > 0)
 32772                     {
 32773                       right = left + width;
 32774                       if (left < leftmost)
 32775                         leftmost = left;
 32776                       if (right > rightmost)
 32777                         rightmost = right;
 32778                     }
 32779                   top = btm + descent + ascent;
 32780                   if (top > highest)
 32781                     highest = top;
 32782                   if (btm < lowest)
 32783                     lowest = btm;
 32784 
 32785                   if (cmp->lbearing > left + lbearing)
 32786                     cmp->lbearing = left + lbearing;
 32787                   if (cmp->rbearing < left + rbearing)
 32788                     cmp->rbearing = left + rbearing;
 32789                 }
 32790             }
 32791 
 32792           /* If there are glyphs whose x-offsets are negative,
 32793              shift all glyphs to the right and make all x-offsets
 32794              non-negative.  */
 32795           if (leftmost < 0)
 32796             {
 32797               for (i = 0; i < cmp->glyph_len; i++)
 32798                 cmp->offsets[i * 2] -= leftmost;
 32799               rightmost -= leftmost;
 32800               cmp->lbearing -= leftmost;
 32801               cmp->rbearing -= leftmost;
 32802             }
 32803 
 32804           if (left_padded && cmp->lbearing < 0)
 32805             {
 32806               for (i = 0; i < cmp->glyph_len; i++)
 32807                 cmp->offsets[i * 2] -= cmp->lbearing;
 32808               rightmost -= cmp->lbearing;
 32809               cmp->rbearing -= cmp->lbearing;
 32810               cmp->lbearing = 0;
 32811             }
 32812           if (right_padded && rightmost < cmp->rbearing)
 32813             {
 32814               rightmost = cmp->rbearing;
 32815             }
 32816 
 32817           cmp->pixel_width = rightmost;
 32818           cmp->ascent = highest;
 32819           cmp->descent = - lowest;
 32820           if (cmp->ascent < font_ascent)
 32821             cmp->ascent = font_ascent;
 32822           if (cmp->descent < font_descent)
 32823             cmp->descent = font_descent;
 32824         }
 32825 
 32826       if (it->glyph_row
 32827           && (cmp->lbearing < 0
 32828               || cmp->rbearing > cmp->pixel_width))
 32829         it->glyph_row->contains_overlapping_glyphs_p = true;
 32830 
 32831       it->pixel_width = cmp->pixel_width;
 32832       it->ascent = it->phys_ascent = cmp->ascent;
 32833       it->descent = it->phys_descent = cmp->descent;
 32834       IT_APPLY_FACE_BOX(it, face);
 32835 
 32836       /* If face has an overline, add the height of the overline
 32837          (1 pixel) and a 1 pixel margin to the character height.  */
 32838       if (face->overline_p)
 32839         it->ascent += clip_to_bounds (0, overline_margin, 1000000);
 32840 
 32841       take_vertical_position_into_account (it);
 32842       if (it->ascent < 0)
 32843         it->ascent = 0;
 32844       if (it->descent < 0)
 32845         it->descent = 0;
 32846 
 32847       if (it->glyph_row && cmp->glyph_len > 0)
 32848         append_composite_glyph (it);
 32849     }
 32850   else if (it->what == IT_COMPOSITION)
 32851     {
 32852       /* A dynamic (automatic) composition.  */
 32853       struct face *face = FACE_FROM_ID (it->f, it->face_id);
 32854       Lisp_Object gstring;
 32855       struct font_metrics metrics;
 32856 
 32857       it->nglyphs = 1;
 32858 
 32859       gstring = composition_gstring_from_id (it->cmp_it.id);
 32860       it->pixel_width
 32861         = composition_gstring_width (gstring, it->cmp_it.from, it->cmp_it.to,
 32862                                      &metrics);
 32863       if (it->pixel_width == 0)
 32864         {
 32865           it->glyph_not_available_p = true;
 32866           it->phys_ascent = it->ascent;
 32867           it->phys_descent = it->descent;
 32868           it->pixel_width = face->font->space_width;
 32869         }
 32870       else
 32871         {
 32872           if (it->glyph_row
 32873               && (metrics.lbearing < 0 || metrics.rbearing > metrics.width))
 32874             it->glyph_row->contains_overlapping_glyphs_p = true;
 32875           it->ascent = it->phys_ascent = metrics.ascent;
 32876           it->descent = it->phys_descent = metrics.descent;
 32877         }
 32878       IT_APPLY_FACE_BOX(it, face);
 32879 
 32880       /* If face has an overline, add the height of the overline
 32881          (1 pixel) and a 1 pixel margin to the character height.  */
 32882       if (face->overline_p)
 32883         it->ascent += clip_to_bounds (0, overline_margin, 1000000);
 32884       take_vertical_position_into_account (it);
 32885       if (it->ascent < 0)
 32886         it->ascent = 0;
 32887       if (it->descent < 0)
 32888         it->descent = 0;
 32889 
 32890       if (it->glyph_row)
 32891         append_composite_glyph (it);
 32892     }
 32893   else if (it->what == IT_GLYPHLESS)
 32894     produce_glyphless_glyph (it, false, Qnil);
 32895   else if (it->what == IT_IMAGE)
 32896     produce_image_glyph (it);
 32897   else if (it->what == IT_STRETCH)
 32898     produce_stretch_glyph (it);
 32899   else if (it->what == IT_XWIDGET)
 32900     produce_xwidget_glyph (it);
 32901 
 32902  done:
 32903   /* Accumulate dimensions.  Note: can't assume that it->descent > 0
 32904      because this isn't true for images with `:ascent 100'.  */
 32905   eassert (it->ascent >= 0 && it->descent >= 0);
 32906   if (it->area == TEXT_AREA)
 32907     it->current_x += it->pixel_width;
 32908 
 32909   if (extra_line_spacing > 0)
 32910     {
 32911       it->descent += extra_line_spacing;
 32912       if (extra_line_spacing > it->max_extra_line_spacing)
 32913         it->max_extra_line_spacing = extra_line_spacing;
 32914     }
 32915 
 32916   it->max_ascent = max (it->max_ascent, it->ascent);
 32917   it->max_descent = max (it->max_descent, it->descent);
 32918   it->max_phys_ascent = max (it->max_phys_ascent, it->phys_ascent);
 32919   it->max_phys_descent = max (it->max_phys_descent, it->phys_descent);
 32920 }
 32921 
 32922 /* EXPORT for RIF:
 32923    Output LEN glyphs starting at START at the nominal cursor position.
 32924    Advance the nominal cursor over the text.  UPDATED_ROW is the glyph row
 32925    being updated, and UPDATED_AREA is the area of that row being updated.  */
 32926 
 32927 void
 32928 gui_write_glyphs (struct window *w, struct glyph_row *updated_row,
 32929                 struct glyph *start, enum glyph_row_area updated_area, int len)
 32930 {
 32931   int x, hpos, chpos = w->phys_cursor.hpos;
 32932 
 32933   eassert (updated_row);
 32934   /* When the window is hscrolled, cursor hpos can legitimately be out
 32935      of bounds, but we draw the cursor at the corresponding window
 32936      margin in that case.  */
 32937   if (!updated_row->reversed_p && chpos < 0)
 32938     chpos = 0;
 32939   if (updated_row->reversed_p && chpos >= updated_row->used[TEXT_AREA])
 32940     chpos = updated_row->used[TEXT_AREA] - 1;
 32941 
 32942   block_input ();
 32943 
 32944   /* Write glyphs.  */
 32945 
 32946   hpos = start - updated_row->glyphs[updated_area];
 32947   x = draw_glyphs (w, w->output_cursor.x,
 32948                    updated_row, updated_area,
 32949                    hpos, hpos + len,
 32950                    DRAW_NORMAL_TEXT, 0);
 32951 
 32952   /* Invalidate old phys cursor if the glyph at its hpos is redrawn.  */
 32953   if (updated_area == TEXT_AREA
 32954       && w->phys_cursor_on_p
 32955       && w->phys_cursor.vpos == w->output_cursor.vpos
 32956       && chpos >= hpos
 32957       && chpos < hpos + len)
 32958     w->phys_cursor_on_p = false;
 32959 
 32960   unblock_input ();
 32961 
 32962   /* Advance the output cursor.  */
 32963   w->output_cursor.hpos += len;
 32964   w->output_cursor.x = x;
 32965 }
 32966 
 32967 
 32968 /* EXPORT for RIF:
 32969    Insert LEN glyphs from START at the nominal cursor position.  */
 32970 
 32971 void
 32972 gui_insert_glyphs (struct window *w, struct glyph_row *updated_row,
 32973                  struct glyph *start, enum glyph_row_area updated_area, int len)
 32974 {
 32975   struct frame *f;
 32976   int line_height, shift_by_width, shifted_region_width;
 32977   struct glyph_row *row;
 32978   struct glyph *glyph;
 32979   int frame_x, frame_y;
 32980   ptrdiff_t hpos;
 32981 
 32982   eassert (updated_row);
 32983   block_input ();
 32984   f = XFRAME (WINDOW_FRAME (w));
 32985 
 32986   /* Get the height of the line we are in.  */
 32987   row = updated_row;
 32988   line_height = row->height;
 32989 
 32990   /* Get the width of the glyphs to insert.  */
 32991   shift_by_width = 0;
 32992   for (glyph = start; glyph < start + len; ++glyph)
 32993     shift_by_width += glyph->pixel_width;
 32994 
 32995   /* Get the width of the region to shift right.  */
 32996   shifted_region_width = (window_box_width (w, updated_area)
 32997                           - w->output_cursor.x
 32998                           - shift_by_width);
 32999 
 33000   /* Shift right.  */
 33001   frame_x = window_box_left (w, updated_area) + w->output_cursor.x;
 33002   frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, w->output_cursor.y);
 33003 
 33004   FRAME_RIF (f)->shift_glyphs_for_insert (f, frame_x, frame_y, shifted_region_width,
 33005                                           line_height, shift_by_width);
 33006 
 33007   /* Write the glyphs.  */
 33008   hpos = start - row->glyphs[updated_area];
 33009   draw_glyphs (w, w->output_cursor.x, row, updated_area,
 33010                hpos, hpos + len,
 33011                DRAW_NORMAL_TEXT, 0);
 33012 
 33013   /* Advance the output cursor.  */
 33014   w->output_cursor.hpos += len;
 33015   w->output_cursor.x += shift_by_width;
 33016   unblock_input ();
 33017 }
 33018 
 33019 
 33020 /* EXPORT for RIF:
 33021    Erase the current text line from the nominal cursor position
 33022    (inclusive) to pixel column TO_X (exclusive).  The idea is that
 33023    everything from TO_X onward is already erased.
 33024 
 33025    TO_X is a pixel position relative to UPDATED_AREA of currently
 33026    updated window W.  TO_X == -1 means clear to the end of this area.  */
 33027 
 33028 void
 33029 gui_clear_end_of_line (struct window *w, struct glyph_row *updated_row,
 33030                        enum glyph_row_area updated_area, int to_x)
 33031 {
 33032   struct frame *f;
 33033   int max_x, min_y, max_y;
 33034   int from_x, from_y, to_y;
 33035   struct face *face;
 33036 
 33037   eassert (updated_row);
 33038   f = XFRAME (w->frame);
 33039   face = FACE_FROM_ID_OR_NULL (f, DEFAULT_FACE_ID);
 33040 
 33041   if (updated_row->full_width_p)
 33042     max_x = (WINDOW_PIXEL_WIDTH (w)
 33043              - (updated_row->mode_line_p ? WINDOW_RIGHT_DIVIDER_WIDTH (w) : 0));
 33044   else
 33045     max_x = window_box_width (w, updated_area);
 33046   max_y = window_text_bottom_y (w);
 33047 
 33048   /* TO_X == 0 means don't do anything.  TO_X < 0 means clear to end
 33049      of window.  For TO_X > 0, truncate to end of drawing area.  */
 33050   if (to_x == 0)
 33051     return;
 33052   else if (to_x < 0)
 33053     to_x = max_x;
 33054   else
 33055     to_x = min (to_x, max_x);
 33056 
 33057   to_y = min (max_y, w->output_cursor.y + updated_row->height);
 33058 
 33059   /* Notice if the cursor will be cleared by this operation.  */
 33060   if (!updated_row->full_width_p)
 33061     notice_overwritten_cursor (w, updated_area,
 33062                                w->output_cursor.x, -1,
 33063                                updated_row->y,
 33064                                MATRIX_ROW_BOTTOM_Y (updated_row));
 33065 
 33066   from_x = w->output_cursor.x;
 33067 
 33068   /* Translate to frame coordinates.  */
 33069   if (updated_row->full_width_p)
 33070     {
 33071       from_x = WINDOW_TO_FRAME_PIXEL_X (w, from_x);
 33072       to_x = WINDOW_TO_FRAME_PIXEL_X (w, to_x);
 33073     }
 33074   else
 33075     {
 33076       int area_left = window_box_left (w, updated_area);
 33077       from_x += area_left;
 33078       to_x += area_left;
 33079     }
 33080 
 33081   min_y = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
 33082   from_y = WINDOW_TO_FRAME_PIXEL_Y (w, max (min_y, w->output_cursor.y));
 33083   to_y = WINDOW_TO_FRAME_PIXEL_Y (w, to_y);
 33084 
 33085   /* Prevent inadvertently clearing to end of the X window.  */
 33086   if (to_x > from_x && to_y > from_y)
 33087     {
 33088       block_input ();
 33089       FRAME_RIF (f)->clear_frame_area (f, from_x, from_y,
 33090                                        to_x - from_x, to_y - from_y);
 33091 
 33092       if (face && !updated_row->stipple_p)
 33093         updated_row->stipple_p = face->stipple;
 33094       unblock_input ();
 33095     }
 33096 }
 33097 
 33098 #endif /* HAVE_WINDOW_SYSTEM */
 33099 
 33100 
 33101 
 33102 /***********************************************************************
 33103                              Cursor types
 33104  ***********************************************************************/
 33105 
 33106 /* Value is the internal representation of the specified cursor type
 33107    ARG.  If type is BAR_CURSOR, return in *WIDTH the specified width
 33108    of the bar cursor.  */
 33109 
 33110 static enum text_cursor_kinds
 33111 get_specified_cursor_type (Lisp_Object arg, int *width)
 33112 {
 33113   enum text_cursor_kinds type;
 33114 
 33115   if (NILP (arg))
 33116     return NO_CURSOR;
 33117 
 33118   if (EQ (arg, Qbox))
 33119     return FILLED_BOX_CURSOR;
 33120 
 33121   if (EQ (arg, Qhollow))
 33122     return HOLLOW_BOX_CURSOR;
 33123 
 33124   if (EQ (arg, Qbar))
 33125     {
 33126       *width = 2;
 33127       return BAR_CURSOR;
 33128     }
 33129 
 33130   if (EQ (arg, Qhbar))
 33131     {
 33132       *width = 2;
 33133       return HBAR_CURSOR;
 33134     }
 33135 
 33136   if (CONSP (arg)
 33137       && RANGED_FIXNUMP (0, XCDR (arg), INT_MAX))
 33138     {
 33139       *width = XFIXNUM (XCDR (arg));
 33140 
 33141       if (EQ (XCAR (arg), Qbox))
 33142           return FILLED_BOX_CURSOR;
 33143       else if (EQ (XCAR (arg), Qbar))
 33144           return BAR_CURSOR;
 33145       else if (EQ (XCAR (arg), Qhbar))
 33146           return HBAR_CURSOR;
 33147     }
 33148 
 33149   /* Treat anything unknown as "hollow box cursor".
 33150      It was bad to signal an error; people have trouble fixing
 33151      .Xdefaults with Emacs, when it has something bad in it.  */
 33152   type = HOLLOW_BOX_CURSOR;
 33153 
 33154   return type;
 33155 }
 33156 
 33157 /* Set the default cursor types for specified frame.  */
 33158 void
 33159 set_frame_cursor_types (struct frame *f, Lisp_Object arg)
 33160 {
 33161   int width = 1;
 33162   Lisp_Object tem;
 33163 
 33164   FRAME_DESIRED_CURSOR (f) = get_specified_cursor_type (arg, &width);
 33165   FRAME_CURSOR_WIDTH (f) = width;
 33166 
 33167   /* By default, set up the blink-off state depending on the on-state.  */
 33168 
 33169   tem = Fassoc (arg, Vblink_cursor_alist, Qnil);
 33170   if (!NILP (tem))
 33171     {
 33172       FRAME_BLINK_OFF_CURSOR (f)
 33173         = get_specified_cursor_type (XCDR (tem), &width);
 33174       FRAME_BLINK_OFF_CURSOR_WIDTH (f) = width;
 33175     }
 33176   else
 33177     FRAME_BLINK_OFF_CURSOR (f) = DEFAULT_CURSOR;
 33178 
 33179   /* Make sure the cursor gets redrawn.  */
 33180   f->cursor_type_changed = true;
 33181 }
 33182 
 33183 
 33184 #ifdef HAVE_WINDOW_SYSTEM
 33185 
 33186 /* Return the cursor we want to be displayed in window W.  Return
 33187    width of bar/hbar cursor through WIDTH arg.  Return with
 33188    ACTIVE_CURSOR arg set to true if cursor in window W is `active'
 33189    (i.e. if the `system caret' should track this cursor).
 33190 
 33191    In a mini-buffer window, we want the cursor only to appear if we
 33192    are reading input from this window.  For the selected window, we
 33193    want the cursor type given by the frame parameter or buffer local
 33194    setting of cursor-type.  If explicitly marked off, draw no cursor.
 33195    In all other cases, we want a hollow box cursor.  */
 33196 
 33197 static enum text_cursor_kinds
 33198 get_window_cursor_type (struct window *w, struct glyph *glyph, int *width,
 33199                         bool *active_cursor)
 33200 {
 33201   struct frame *f = XFRAME (w->frame);
 33202   struct buffer *b = XBUFFER (w->contents);
 33203   int cursor_type = DEFAULT_CURSOR;
 33204   Lisp_Object alt_cursor;
 33205   bool non_selected = false;
 33206 
 33207   *active_cursor = true;
 33208 
 33209   /* Echo area */
 33210   if (cursor_in_echo_area
 33211       && FRAME_HAS_MINIBUF_P (f)
 33212       && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
 33213     {
 33214       if (w == XWINDOW (echo_area_window))
 33215         {
 33216           if (EQ (BVAR (b, cursor_type), Qt) || NILP (BVAR (b, cursor_type)))
 33217             {
 33218               *width = FRAME_CURSOR_WIDTH (f);
 33219               return FRAME_DESIRED_CURSOR (f);
 33220             }
 33221           else
 33222             return get_specified_cursor_type (BVAR (b, cursor_type), width);
 33223         }
 33224 
 33225       *active_cursor = false;
 33226       non_selected = true;
 33227     }
 33228 
 33229   /* Detect a nonselected window or nonselected frame.  */
 33230   else if (w != XWINDOW (f->selected_window)
 33231            || f != FRAME_DISPLAY_INFO (f)->highlight_frame)
 33232     {
 33233       *active_cursor = false;
 33234 
 33235       if (MINI_WINDOW_P (w) &&
 33236           (minibuf_level == 0
 33237            || is_minibuffer (0, w->contents)))
 33238         return NO_CURSOR;
 33239 
 33240       non_selected = true;
 33241     }
 33242 
 33243   /* Never display a cursor in a window in which cursor-type is nil.  */
 33244   if (NILP (BVAR (b, cursor_type)))
 33245     return NO_CURSOR;
 33246 
 33247   /* Get the normal cursor type for this window.  */
 33248   if (EQ (BVAR (b, cursor_type), Qt))
 33249     {
 33250       cursor_type = FRAME_DESIRED_CURSOR (f);
 33251       *width = FRAME_CURSOR_WIDTH (f);
 33252     }
 33253   else
 33254     cursor_type = get_specified_cursor_type (BVAR (b, cursor_type), width);
 33255 
 33256   /* Use cursor-in-non-selected-windows instead
 33257      for non-selected window or frame.  */
 33258   if (non_selected)
 33259     {
 33260       alt_cursor = BVAR (b, cursor_in_non_selected_windows);
 33261       if (!EQ (Qt, alt_cursor))
 33262         return get_specified_cursor_type (alt_cursor, width);
 33263       /* t means modify the normal cursor type.  */
 33264       if (cursor_type == FILLED_BOX_CURSOR)
 33265         cursor_type = HOLLOW_BOX_CURSOR;
 33266       else if (cursor_type == BAR_CURSOR && *width > 1)
 33267         --*width;
 33268       return cursor_type;
 33269     }
 33270 
 33271   /* Use normal cursor if not blinked off.  */
 33272   if (!w->cursor_off_p)
 33273     {
 33274       if (glyph != NULL && glyph->type == XWIDGET_GLYPH)
 33275         return NO_CURSOR;
 33276       if (glyph != NULL && glyph->type == IMAGE_GLYPH)
 33277         {
 33278           if (cursor_type == FILLED_BOX_CURSOR)
 33279             {
 33280               /* Using a block cursor on large images can be very
 33281                  annoying.  So use a hollow cursor for "large" images.
 33282                  If image is not transparent (no mask), also use
 33283                  hollow cursor.  */
 33284               struct image *img = IMAGE_OPT_FROM_ID (f, glyph->u.img_id);
 33285               if (img != NULL && IMAGEP (img->spec))
 33286                 {
 33287                   /* Interpret "large" as >SIZExSIZE and >NxN where
 33288                      SIZE is the value from cursor-type of the form
 33289                      (box . SIZE), where N = size of default frame
 33290                      font size.  So, setting cursor-type to (box . 32)
 33291                      should cover most of the "tiny" icons people may
 33292                      use.  */
 33293                   if (!img->mask
 33294                       || (CONSP (BVAR (b, cursor_type))
 33295                           && img->width > max (*width, WINDOW_FRAME_COLUMN_WIDTH (w))
 33296                           && img->height > max (*width, WINDOW_FRAME_LINE_HEIGHT (w))))
 33297                     cursor_type = HOLLOW_BOX_CURSOR;
 33298                 }
 33299             }
 33300           else if (cursor_type != NO_CURSOR)
 33301             {
 33302               /* Display current only supports BOX and HOLLOW cursors for images.
 33303                  So for now, unconditionally use a HOLLOW cursor when cursor is
 33304                  not a solid box cursor.  */
 33305               cursor_type = HOLLOW_BOX_CURSOR;
 33306             }
 33307       }
 33308       return cursor_type;
 33309     }
 33310 
 33311   /* Cursor is blinked off, so determine how to "toggle" it.  */
 33312 
 33313   /* First look for an entry matching the buffer's cursor-type in blink-cursor-alist.  */
 33314   if ((alt_cursor = Fassoc (BVAR (b, cursor_type), Vblink_cursor_alist, Qnil), !NILP (alt_cursor)))
 33315     return get_specified_cursor_type (XCDR (alt_cursor), width);
 33316 
 33317   /* Then see if frame has specified a specific blink off cursor type.  */
 33318   if (FRAME_BLINK_OFF_CURSOR (f) != DEFAULT_CURSOR)
 33319     {
 33320       *width = FRAME_BLINK_OFF_CURSOR_WIDTH (f);
 33321       return FRAME_BLINK_OFF_CURSOR (f);
 33322     }
 33323 
 33324 #if false
 33325   /* Some people liked having a permanently visible blinking cursor,
 33326      while others had very strong opinions against it.  So it was
 33327      decided to remove it.  KFS 2003-09-03 */
 33328 
 33329   /* Finally perform built-in cursor blinking:
 33330        filled box      <->   hollow box
 33331        wide [h]bar     <->   narrow [h]bar
 33332        narrow [h]bar   <->   no cursor
 33333        other type      <->   no cursor  */
 33334 
 33335   if (cursor_type == FILLED_BOX_CURSOR)
 33336     return HOLLOW_BOX_CURSOR;
 33337 
 33338   if ((cursor_type == BAR_CURSOR || cursor_type == HBAR_CURSOR) && *width > 1)
 33339     {
 33340       *width = 1;
 33341       return cursor_type;
 33342     }
 33343 #endif
 33344 
 33345   return NO_CURSOR;
 33346 }
 33347 
 33348 
 33349 /* Notice when the text cursor of window W has been completely
 33350    overwritten by a drawing operation that outputs glyphs in AREA
 33351    starting at X0 and ending at X1 in the line starting at Y0 and
 33352    ending at Y1.  X coordinates are area-relative.  X1 < 0 means all
 33353    the rest of the line after X0 has been written.  Y coordinates
 33354    are window-relative.  */
 33355 
 33356 static void
 33357 notice_overwritten_cursor (struct window *w, enum glyph_row_area area,
 33358                            int x0, int x1, int y0, int y1)
 33359 {
 33360   int cx0, cx1, cy0, cy1;
 33361   struct glyph_row *row;
 33362 
 33363   if (!w->phys_cursor_on_p)
 33364     return;
 33365   if (area != TEXT_AREA)
 33366     return;
 33367 
 33368   if (w->phys_cursor.vpos < 0
 33369       || w->phys_cursor.vpos >= w->current_matrix->nrows
 33370       || (row = w->current_matrix->rows + w->phys_cursor.vpos,
 33371           !(row->enabled_p && MATRIX_ROW_DISPLAYS_TEXT_P (row))))
 33372     return;
 33373 
 33374   if (row->cursor_in_fringe_p)
 33375     {
 33376       row->cursor_in_fringe_p = false;
 33377       draw_fringe_bitmap (w, row, row->reversed_p);
 33378       w->phys_cursor_on_p = false;
 33379       return;
 33380     }
 33381 
 33382   cx0 = w->phys_cursor.x;
 33383   cx1 = cx0 + w->phys_cursor_width;
 33384   if (x0 > cx0 || (x1 >= 0 && x1 < cx1))
 33385     return;
 33386 
 33387   /* The cursor image will be completely removed from the
 33388      screen if the output area intersects the cursor area in
 33389      y-direction.  When we draw in [y0 y1[, and some part of
 33390      the cursor is at y < y0, that part must have been drawn
 33391      before.  When scrolling, the cursor is erased before
 33392      actually scrolling, so we don't come here.  When not
 33393      scrolling, the rows above the old cursor row must have
 33394      changed, and in this case these rows must have written
 33395      over the cursor image.
 33396 
 33397      Likewise if part of the cursor is below y1, with the
 33398      exception of the cursor being in the first blank row at
 33399      the buffer and window end because update_text_area
 33400      doesn't draw that row.  (Except when it does, but
 33401      that's handled in update_text_area.)  */
 33402 
 33403   cy0 = w->phys_cursor.y;
 33404   cy1 = cy0 + w->phys_cursor_height;
 33405   if ((y0 < cy0 || y0 >= cy1) && (y1 <= cy0 || y1 >= cy1))
 33406     return;
 33407 
 33408   w->phys_cursor_on_p = false;
 33409 }
 33410 
 33411 #endif /* HAVE_WINDOW_SYSTEM */
 33412 
 33413 
 33414 /************************************************************************
 33415                               Mouse Face
 33416  ************************************************************************/
 33417 
 33418 #ifdef HAVE_WINDOW_SYSTEM
 33419 
 33420 /* EXPORT for RIF:
 33421    Fix the display of area AREA of overlapping row ROW in window W
 33422    with respect to the overlapping part OVERLAPS.  */
 33423 
 33424 void
 33425 gui_fix_overlapping_area (struct window *w, struct glyph_row *row,
 33426                         enum glyph_row_area area, int overlaps)
 33427 {
 33428   int i, x;
 33429 
 33430   block_input ();
 33431 
 33432   x = 0;
 33433   for (i = 0; i < row->used[area];)
 33434     {
 33435       if (row->glyphs[area][i].overlaps_vertically_p)
 33436         {
 33437           int start = i, start_x = x;
 33438 
 33439           do
 33440             {
 33441               x += row->glyphs[area][i].pixel_width;
 33442               ++i;
 33443             }
 33444           while (i < row->used[area]
 33445                  && row->glyphs[area][i].overlaps_vertically_p);
 33446 
 33447           draw_glyphs (w, start_x, row, area,
 33448                        start, i,
 33449                        DRAW_NORMAL_TEXT, overlaps);
 33450         }
 33451       else
 33452         {
 33453           x += row->glyphs[area][i].pixel_width;
 33454           ++i;
 33455         }
 33456     }
 33457 
 33458   unblock_input ();
 33459 }
 33460 
 33461 
 33462 /* EXPORT:
 33463    Draw the cursor glyph of window W in glyph row ROW.  See the
 33464    comment of draw_glyphs for the meaning of HL.  */
 33465 
 33466 void
 33467 draw_phys_cursor_glyph (struct window *w, struct glyph_row *row,
 33468                         enum draw_glyphs_face hl)
 33469 {
 33470   /* If cursor hpos is out of bounds, don't draw garbage.  This can
 33471      happen in mini-buffer windows when switching between echo area
 33472      glyphs and mini-buffer.  */
 33473   if ((row->reversed_p
 33474        ? (w->phys_cursor.hpos >= 0)
 33475        : (w->phys_cursor.hpos < row->used[TEXT_AREA])))
 33476     {
 33477       bool on_p = w->phys_cursor_on_p;
 33478       int x1;
 33479       int hpos = w->phys_cursor.hpos;
 33480 
 33481       /* When the window is hscrolled, cursor hpos can legitimately be
 33482          out of bounds, but we draw the cursor at the corresponding
 33483          window margin in that case.  */
 33484       if (!row->reversed_p && hpos < 0)
 33485         hpos = 0;
 33486       if (row->reversed_p && hpos >= row->used[TEXT_AREA])
 33487         hpos = row->used[TEXT_AREA] - 1;
 33488 
 33489       x1 = draw_glyphs (w, w->phys_cursor.x, row, TEXT_AREA, hpos, hpos + 1,
 33490                         hl, 0);
 33491       w->phys_cursor_on_p = on_p;
 33492 
 33493       if (hl == DRAW_CURSOR)
 33494         w->phys_cursor_width = x1 - w->phys_cursor.x;
 33495       /* When we erase the cursor, and ROW is overlapped by other
 33496          rows, make sure that these overlapping parts of other rows
 33497          are redrawn.  */
 33498       else if (hl == DRAW_NORMAL_TEXT && row->overlapped_p)
 33499         {
 33500           w->phys_cursor_width = x1 - w->phys_cursor.x;
 33501 
 33502           if (row > w->current_matrix->rows
 33503               && MATRIX_ROW_OVERLAPS_SUCC_P (row - 1))
 33504             gui_fix_overlapping_area (w, row - 1, TEXT_AREA,
 33505                                     OVERLAPS_ERASED_CURSOR);
 33506 
 33507           if (MATRIX_ROW_BOTTOM_Y (row) < window_text_bottom_y (w)
 33508               && MATRIX_ROW_OVERLAPS_PRED_P (row + 1))
 33509             gui_fix_overlapping_area (w, row + 1, TEXT_AREA,
 33510                                     OVERLAPS_ERASED_CURSOR);
 33511         }
 33512     }
 33513 }
 33514 
 33515 
 33516 /* Erase the image of a cursor of window W from the screen.  */
 33517 
 33518 void
 33519 erase_phys_cursor (struct window *w)
 33520 {
 33521   struct frame *f = XFRAME (w->frame);
 33522   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 33523   int hpos = w->phys_cursor.hpos;
 33524   int vpos = w->phys_cursor.vpos;
 33525   bool mouse_face_here_p = false;
 33526   struct glyph_matrix *active_glyphs = w->current_matrix;
 33527   struct glyph_row *cursor_row;
 33528   struct glyph *cursor_glyph;
 33529   enum draw_glyphs_face hl;
 33530 
 33531   /* No cursor displayed or row invalidated => nothing to do on the
 33532      screen.  */
 33533   if (w->phys_cursor_type == NO_CURSOR)
 33534     goto mark_cursor_off;
 33535 
 33536   /* VPOS >= active_glyphs->nrows means that window has been resized.
 33537      Don't bother to erase the cursor.  */
 33538   if (vpos >= active_glyphs->nrows)
 33539     goto mark_cursor_off;
 33540 
 33541   /* If row containing cursor is marked invalid, there is nothing we
 33542      can do.  */
 33543   cursor_row = MATRIX_ROW (active_glyphs, vpos);
 33544   if (!cursor_row->enabled_p)
 33545     goto mark_cursor_off;
 33546 
 33547   /* If line spacing is > 0, old cursor may only be partially visible in
 33548      window after split-window.  So adjust visible height.  */
 33549   cursor_row->visible_height = min (cursor_row->visible_height,
 33550                                     window_text_bottom_y (w) - cursor_row->y);
 33551 
 33552   /* If row is completely invisible, don't attempt to delete a cursor which
 33553      isn't there.  This can happen if cursor is at top of a window, and
 33554      we switch to a buffer with a header line in that window.  */
 33555   if (cursor_row->visible_height <= 0)
 33556     goto mark_cursor_off;
 33557 
 33558   /* If cursor is in the fringe, erase by drawing actual bitmap there.  */
 33559   if (cursor_row->cursor_in_fringe_p)
 33560     {
 33561       cursor_row->cursor_in_fringe_p = false;
 33562       draw_fringe_bitmap (w, cursor_row, cursor_row->reversed_p);
 33563       goto mark_cursor_off;
 33564     }
 33565 
 33566   /* This can happen when the new row is shorter than the old one.
 33567      In this case, either draw_glyphs or clear_end_of_line
 33568      should have cleared the cursor.  Note that we wouldn't be
 33569      able to erase the cursor in this case because we don't have a
 33570      cursor glyph at hand.  */
 33571   if ((cursor_row->reversed_p
 33572        ? (w->phys_cursor.hpos < 0)
 33573        : (w->phys_cursor.hpos >= cursor_row->used[TEXT_AREA])))
 33574     goto mark_cursor_off;
 33575 
 33576   /* When the window is hscrolled, cursor hpos can legitimately be out
 33577      of bounds, but we draw the cursor at the corresponding window
 33578      margin in that case.  */
 33579   if (!cursor_row->reversed_p && hpos < 0)
 33580     hpos = 0;
 33581   if (cursor_row->reversed_p && hpos >= cursor_row->used[TEXT_AREA])
 33582     hpos = cursor_row->used[TEXT_AREA] - 1;
 33583 
 33584   /* If the cursor is in the mouse face area, redisplay that when
 33585      we clear the cursor.  */
 33586   if (! NILP (hlinfo->mouse_face_window)
 33587       && coords_in_mouse_face_p (w, hpos, vpos)
 33588       /* Don't redraw the cursor's spot in mouse face if it is at the
 33589          end of a line (on a newline).  The cursor appears there, but
 33590          mouse highlighting does not.  */
 33591       && cursor_row->used[TEXT_AREA] > hpos && hpos >= 0)
 33592     mouse_face_here_p = true;
 33593 
 33594 #ifdef HAVE_WINDOW_SYSTEM
 33595   /* Since erasing the phys cursor will probably lead to corruption of
 33596      the mouse face display if the glyph's pixel_width is not kept up
 33597      to date with the :box property of the mouse face, just redraw the
 33598      mouse face.  */
 33599   if (FRAME_WINDOW_P (WINDOW_XFRAME (w)) && mouse_face_here_p)
 33600     {
 33601       w->phys_cursor_on_p = false;
 33602       w->phys_cursor_type = NO_CURSOR;
 33603       show_mouse_face (MOUSE_HL_INFO (WINDOW_XFRAME (w)), DRAW_MOUSE_FACE);
 33604       return;
 33605     }
 33606 #endif
 33607 
 33608   /* Maybe clear the display under the cursor.  */
 33609   if (w->phys_cursor_type == HOLLOW_BOX_CURSOR)
 33610     {
 33611       int x, y;
 33612       int tab_line_height = WINDOW_TAB_LINE_HEIGHT (w);
 33613       int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
 33614       int width;
 33615 
 33616       cursor_glyph = get_phys_cursor_glyph (w);
 33617       if (cursor_glyph == NULL)
 33618         goto mark_cursor_off;
 33619 
 33620       width = cursor_glyph->pixel_width;
 33621       x = w->phys_cursor.x;
 33622       if (x < 0)
 33623         {
 33624           width += x;
 33625           x = 0;
 33626         }
 33627       width = min (width, window_box_width (w, TEXT_AREA) - x);
 33628       y = WINDOW_TO_FRAME_PIXEL_Y (w, max (tab_line_height, max (header_line_height, cursor_row->y)));
 33629       x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, x);
 33630 
 33631       if (width > 0)
 33632         FRAME_RIF (f)->clear_frame_area (f, x, y, width, cursor_row->visible_height);
 33633     }
 33634 
 33635   /* Erase the cursor by redrawing the character underneath it.  */
 33636   if (mouse_face_here_p)
 33637     hl = DRAW_MOUSE_FACE;
 33638   else
 33639     hl = DRAW_NORMAL_TEXT;
 33640   draw_phys_cursor_glyph (w, cursor_row, hl);
 33641 
 33642  mark_cursor_off:
 33643   w->phys_cursor_on_p = false;
 33644   w->phys_cursor_type = NO_CURSOR;
 33645 }
 33646 
 33647 
 33648 /* Display or clear cursor of window W.  If !ON, clear the cursor.
 33649    If ON, display the cursor; where to put the cursor is specified by
 33650    HPOS, VPOS, X and Y.  */
 33651 
 33652 void
 33653 display_and_set_cursor (struct window *w, bool on,
 33654                         int hpos, int vpos, int x, int y)
 33655 {
 33656   struct frame *f = XFRAME (w->frame);
 33657   int new_cursor_type;
 33658   int new_cursor_width UNINIT;
 33659   bool active_cursor;
 33660   struct glyph_row *glyph_row;
 33661   struct glyph *glyph;
 33662 
 33663   /* This is pointless on invisible frames, and dangerous on garbaged
 33664      windows and frames; in the latter case, the frame or window may
 33665      be in the midst of changing its size, and x and y may be off the
 33666      window.  */
 33667   if (! FRAME_REDISPLAY_P (f)
 33668       || vpos >= w->current_matrix->nrows
 33669       || hpos >= w->current_matrix->matrix_w)
 33670     return;
 33671 
 33672   /* If cursor is off and we want it off, return quickly.  */
 33673   if (!on && !w->phys_cursor_on_p)
 33674     return;
 33675 
 33676   glyph_row = MATRIX_ROW (w->current_matrix, vpos);
 33677   /* If cursor row is not enabled, we don't really know where to
 33678      display the cursor.  */
 33679   if (!glyph_row->enabled_p)
 33680     {
 33681       w->phys_cursor_on_p = false;
 33682       return;
 33683     }
 33684 
 33685   /* A frame might be marked garbaged even though its cursor position
 33686      is correct, and will not change upon subsequent redisplay.  This
 33687      happens in some rare situations, like toggling the sort order in
 33688      Dired windows.  We've already established that VPOS is valid, so
 33689      it shouldn't do any harm to record the cursor position, as we are
 33690      going to return without acting on it anyway.  Otherwise, expose
 33691      events might come in and call update_window_cursor, which will
 33692      blindly use outdated values in w->phys_cursor.  */
 33693   if (FRAME_GARBAGED_P (f))
 33694     {
 33695       if (on)
 33696         {
 33697           w->phys_cursor.x = x;
 33698           w->phys_cursor.y = glyph_row->y;
 33699           w->phys_cursor.hpos = hpos;
 33700           w->phys_cursor.vpos = vpos;
 33701         }
 33702       return;
 33703     }
 33704 
 33705   glyph = NULL;
 33706   if (0 <= hpos && hpos < glyph_row->used[TEXT_AREA])
 33707     glyph = glyph_row->glyphs[TEXT_AREA] + hpos;
 33708 
 33709   eassert (input_blocked_p ());
 33710 
 33711   /* Set new_cursor_type to the cursor we want to be displayed.  */
 33712   new_cursor_type = get_window_cursor_type (w, glyph,
 33713                                             &new_cursor_width, &active_cursor);
 33714 
 33715   /* If cursor is currently being shown and we don't want it to be or
 33716      it is in the wrong place, or the cursor type is not what we want,
 33717      erase it.  */
 33718   if (w->phys_cursor_on_p
 33719       && (!on
 33720           || w->phys_cursor.x != x
 33721           || w->phys_cursor.y != y
 33722           /* HPOS can be negative in R2L rows whose
 33723              exact_window_width_line_p flag is set (i.e. their newline
 33724              would "overflow into the fringe").  */
 33725           || hpos < 0
 33726           || new_cursor_type != w->phys_cursor_type
 33727           || ((new_cursor_type == BAR_CURSOR || new_cursor_type == HBAR_CURSOR)
 33728               && new_cursor_width != w->phys_cursor_width)))
 33729     erase_phys_cursor (w);
 33730 
 33731   /* Don't check phys_cursor_on_p here because that flag is only set
 33732      to false in some cases where we know that the cursor has been
 33733      completely erased, to avoid the extra work of erasing the cursor
 33734      twice.  In other words, phys_cursor_on_p can be true and the cursor
 33735      still not be visible, or it has only been partly erased.  */
 33736   if (on)
 33737     {
 33738       w->phys_cursor_ascent = glyph_row->ascent;
 33739       w->phys_cursor_height = glyph_row->height;
 33740 
 33741       /* Set phys_cursor_.* before x_draw_.* is called because some
 33742          of them may need the information.  */
 33743       w->phys_cursor.x = x;
 33744       w->phys_cursor.y = glyph_row->y;
 33745       w->phys_cursor.hpos = hpos;
 33746       w->phys_cursor.vpos = vpos;
 33747     }
 33748 
 33749   FRAME_RIF (f)->draw_window_cursor (w, glyph_row, x, y,
 33750                                      new_cursor_type, new_cursor_width,
 33751                                      on, active_cursor);
 33752 }
 33753 
 33754 
 33755 /* Switch the display of W's cursor on or off, according to the value
 33756    of ON.  */
 33757 
 33758 static void
 33759 update_window_cursor (struct window *w, bool on)
 33760 {
 33761   /* Don't update cursor in windows whose frame is in the process
 33762      of being deleted.  */
 33763   if (w->current_matrix)
 33764     {
 33765       int hpos = w->phys_cursor.hpos;
 33766       int vpos = w->phys_cursor.vpos;
 33767       struct glyph_row *row;
 33768 
 33769       if (vpos >= w->current_matrix->nrows
 33770           || hpos >= w->current_matrix->matrix_w)
 33771         return;
 33772 
 33773       row = MATRIX_ROW (w->current_matrix, vpos);
 33774 
 33775       /* When the window is hscrolled, cursor hpos can legitimately be
 33776          out of bounds, but we draw the cursor at the corresponding
 33777          window margin in that case.  */
 33778       if (!row->reversed_p && hpos < 0)
 33779         hpos = 0;
 33780       if (row->reversed_p && hpos >= row->used[TEXT_AREA])
 33781         hpos = row->used[TEXT_AREA] - 1;
 33782 
 33783       block_input ();
 33784       display_and_set_cursor (w, on, hpos, vpos,
 33785                               w->phys_cursor.x, w->phys_cursor.y);
 33786       unblock_input ();
 33787     }
 33788 }
 33789 
 33790 
 33791 /* Call update_window_cursor with parameter ON_P on all leaf windows
 33792    in the window tree rooted at W.  */
 33793 
 33794 static void
 33795 update_cursor_in_window_tree (struct window *w, bool on_p)
 33796 {
 33797   while (w)
 33798     {
 33799       if (WINDOWP (w->contents))
 33800         update_cursor_in_window_tree (XWINDOW (w->contents), on_p);
 33801       else
 33802         update_window_cursor (w, on_p);
 33803 
 33804       w = NILP (w->next) ? 0 : XWINDOW (w->next);
 33805     }
 33806 }
 33807 
 33808 
 33809 /* EXPORT:
 33810    Display the cursor on window W, or clear it, according to ON_P.
 33811    Don't change the cursor's position.  */
 33812 
 33813 void
 33814 gui_update_cursor (struct frame *f, bool on_p)
 33815 {
 33816   update_cursor_in_window_tree (XWINDOW (f->root_window), on_p);
 33817 }
 33818 
 33819 
 33820 /* EXPORT:
 33821    Clear the cursor of window W to background color, and mark the
 33822    cursor as not shown.  This is used when the text where the cursor
 33823    is about to be rewritten.  */
 33824 
 33825 void
 33826 gui_clear_cursor (struct window *w)
 33827 {
 33828   if (FRAME_REDISPLAY_P (XFRAME (w->frame)) && w->phys_cursor_on_p)
 33829     update_window_cursor (w, false);
 33830 }
 33831 
 33832 #endif /* HAVE_WINDOW_SYSTEM */
 33833 
 33834 /* Implementation of draw_row_with_mouse_face for GUI sessions, GPM,
 33835    and MSDOS.  */
 33836 static void
 33837 draw_row_with_mouse_face (struct window *w, int start_x, struct glyph_row *row,
 33838                           int start_hpos, int end_hpos,
 33839                           enum draw_glyphs_face draw)
 33840 {
 33841 #ifdef HAVE_WINDOW_SYSTEM
 33842   if (FRAME_WINDOW_P (XFRAME (w->frame)))
 33843     {
 33844       draw_glyphs (w, start_x, row, TEXT_AREA, start_hpos, end_hpos, draw, 0);
 33845       return;
 33846     }
 33847 #endif
 33848 
 33849 #ifndef HAVE_ANDROID
 33850   tty_draw_row_with_mouse_face (w, row, start_hpos, end_hpos, draw);
 33851 #endif
 33852 }
 33853 
 33854 /* Display the active region described by mouse_face_* according to DRAW.  */
 33855 
 33856 static void
 33857 show_mouse_face (Mouse_HLInfo *hlinfo, enum draw_glyphs_face draw)
 33858 {
 33859   /* Don't bother doing anything if the mouse-face window is not set
 33860      up.  */
 33861   if (!WINDOWP (hlinfo->mouse_face_window))
 33862     return;
 33863 
 33864   struct window *w = XWINDOW (hlinfo->mouse_face_window);
 33865   struct frame *f = XFRAME (WINDOW_FRAME (w));
 33866 
 33867   /* Don't bother doing anything if we are on a wrong frame.  */
 33868   if (f != hlinfo->mouse_face_mouse_frame)
 33869     return;
 33870 
 33871   if (/* If window is in the process of being destroyed, don't bother
 33872          to do anything.  */
 33873       w->current_matrix != NULL
 33874       /* Don't update mouse highlight if hidden.  */
 33875       && (draw != DRAW_MOUSE_FACE || !hlinfo->mouse_face_hidden)
 33876       /* Recognize when we are called to operate on rows that don't exist
 33877          anymore.  This can happen when a window is split.  */
 33878       && hlinfo->mouse_face_end_row < w->current_matrix->nrows)
 33879     {
 33880       bool phys_cursor_on_p = w->phys_cursor_on_p;
 33881 #ifdef HAVE_WINDOW_SYSTEM
 33882       int mouse_off = 0;
 33883 #endif
 33884       struct glyph_row *row, *first, *last;
 33885 
 33886       first = MATRIX_ROW (w->current_matrix, hlinfo->mouse_face_beg_row);
 33887       last = MATRIX_ROW (w->current_matrix, hlinfo->mouse_face_end_row);
 33888 
 33889       for (row = first; row <= last && row->enabled_p; ++row)
 33890         {
 33891           int start_hpos, end_hpos, start_x;
 33892 
 33893           /* For all but the first row, the highlight starts at column 0.  */
 33894           if (row == first)
 33895             {
 33896               /* R2L rows have BEG and END in reversed order, but the
 33897                  screen drawing geometry is always left to right.  So
 33898                  we need to mirror the beginning and end of the
 33899                  highlighted area in R2L rows.  */
 33900               if (!row->reversed_p)
 33901                 {
 33902                   start_hpos = hlinfo->mouse_face_beg_col;
 33903                   start_x = hlinfo->mouse_face_beg_x;
 33904                 }
 33905               else if (row == last)
 33906                 {
 33907                   start_hpos = hlinfo->mouse_face_end_col;
 33908                   start_x = hlinfo->mouse_face_end_x;
 33909                 }
 33910               else
 33911                 {
 33912                   start_hpos = 0;
 33913                   start_x = 0;
 33914                 }
 33915             }
 33916           else if (row->reversed_p && row == last)
 33917             {
 33918               start_hpos = hlinfo->mouse_face_end_col;
 33919               start_x = hlinfo->mouse_face_end_x;
 33920             }
 33921           else
 33922             {
 33923               start_hpos = 0;
 33924               start_x = 0;
 33925             }
 33926 
 33927           if (row == last)
 33928             {
 33929               if (!row->reversed_p)
 33930                 end_hpos = hlinfo->mouse_face_end_col;
 33931               else if (row == first)
 33932                 end_hpos = hlinfo->mouse_face_beg_col;
 33933               else
 33934                 {
 33935                   end_hpos = row->used[TEXT_AREA];
 33936                   if (draw == DRAW_NORMAL_TEXT)
 33937                     row->fill_line_p = true; /* Clear to end of line.  */
 33938                 }
 33939             }
 33940           else if (row->reversed_p && row == first)
 33941             end_hpos = hlinfo->mouse_face_beg_col;
 33942           else
 33943             {
 33944               end_hpos = row->used[TEXT_AREA];
 33945               if (draw == DRAW_NORMAL_TEXT)
 33946                 row->fill_line_p = true; /* Clear to end of line.  */
 33947             }
 33948 
 33949           if (end_hpos > start_hpos)
 33950             {
 33951               draw_row_with_mouse_face (w, start_x, row,
 33952                                         start_hpos, end_hpos, draw);
 33953 
 33954               row->mouse_face_p
 33955                 = draw == DRAW_MOUSE_FACE || draw == DRAW_IMAGE_RAISED;
 33956             }
 33957 #ifdef HAVE_WINDOW_SYSTEM
 33958           /* Compute the cursor offset due to mouse-highlight.  */
 33959           if ((MATRIX_ROW_VPOS (row, w->current_matrix) == w->phys_cursor.vpos)
 33960               /* But not when highlighting a pseudo window, such as
 33961                  the toolbar, which can't have a cursor anyway.  */
 33962               && !w->pseudo_window_p
 33963               && draw == DRAW_MOUSE_FACE)
 33964             get_cursor_offset_for_mouse_face (w, row, &mouse_off);
 33965 #endif
 33966         }
 33967 
 33968       /* When we've written over the cursor, arrange for it to
 33969          be displayed again.  */
 33970       if (FRAME_WINDOW_P (f)
 33971           && phys_cursor_on_p && !w->phys_cursor_on_p)
 33972         {
 33973 #ifdef HAVE_WINDOW_SYSTEM
 33974           int hpos = w->phys_cursor.hpos;
 33975           int old_phys_cursor_x = w->phys_cursor.x;
 33976 
 33977           /* When the window is hscrolled, cursor hpos can legitimately be
 33978              out of bounds, but we draw the cursor at the corresponding
 33979              window margin in that case.  */
 33980           if (!row->reversed_p && hpos < 0)
 33981             hpos = 0;
 33982           if (row->reversed_p && hpos >= row->used[TEXT_AREA])
 33983             hpos = row->used[TEXT_AREA] - 1;
 33984 
 33985           block_input ();
 33986           display_and_set_cursor (w, true, hpos, w->phys_cursor.vpos,
 33987                                   w->phys_cursor.x + mouse_off,
 33988                                   w->phys_cursor.y);
 33989           /* Restore the original cursor coordinates, perhaps modified
 33990              to account for mouse-highlight.  */
 33991           w->phys_cursor.x = old_phys_cursor_x;
 33992           unblock_input ();
 33993 #endif  /* HAVE_WINDOW_SYSTEM */
 33994         }
 33995     }
 33996 
 33997 #ifdef HAVE_WINDOW_SYSTEM
 33998   /* Change the mouse cursor.  */
 33999   if (FRAME_WINDOW_P (f) && NILP (track_mouse))
 34000     {
 34001       if (draw == DRAW_NORMAL_TEXT
 34002 #ifndef HAVE_EXT_TOOL_BAR
 34003           && !EQ (hlinfo->mouse_face_window, f->tool_bar_window)
 34004 #endif
 34005           && !EQ (hlinfo->mouse_face_window, f->tab_bar_window))
 34006         FRAME_RIF (f)->define_frame_cursor (f, FRAME_OUTPUT_DATA (f)->text_cursor);
 34007       else
 34008       if (draw == DRAW_MOUSE_FACE)
 34009         FRAME_RIF (f)->define_frame_cursor (f, FRAME_OUTPUT_DATA (f)->hand_cursor);
 34010       else
 34011         FRAME_RIF (f)->define_frame_cursor (f, FRAME_OUTPUT_DATA (f)->nontext_cursor);
 34012     }
 34013 #endif  /* HAVE_WINDOW_SYSTEM */
 34014 }
 34015 
 34016 /* EXPORT:
 34017    Clear out the mouse-highlighted active region.
 34018    Redraw it un-highlighted first.  Value is true if mouse
 34019    face was actually drawn unhighlighted.  */
 34020 
 34021 bool
 34022 clear_mouse_face (Mouse_HLInfo *hlinfo)
 34023 {
 34024   bool cleared
 34025     = !hlinfo->mouse_face_hidden && !NILP (hlinfo->mouse_face_window);
 34026   if (cleared)
 34027     show_mouse_face (hlinfo, DRAW_NORMAL_TEXT);
 34028   hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
 34029   hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
 34030   hlinfo->mouse_face_window = Qnil;
 34031   hlinfo->mouse_face_overlay = Qnil;
 34032   return cleared;
 34033 }
 34034 
 34035 /* Return true if the coordinates HPOS and VPOS on windows W are
 34036    within the mouse face on that window.  */
 34037 static bool
 34038 coords_in_mouse_face_p (struct window *w, int hpos, int vpos)
 34039 {
 34040   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
 34041 
 34042   /* Quickly resolve the easy cases.  */
 34043   if (!(WINDOWP (hlinfo->mouse_face_window)
 34044         && XWINDOW (hlinfo->mouse_face_window) == w))
 34045     return false;
 34046   if (vpos < hlinfo->mouse_face_beg_row
 34047       || vpos > hlinfo->mouse_face_end_row)
 34048     return false;
 34049   if (vpos > hlinfo->mouse_face_beg_row
 34050       && vpos < hlinfo->mouse_face_end_row)
 34051     return true;
 34052 
 34053   if (!MATRIX_ROW (w->current_matrix, vpos)->reversed_p)
 34054     {
 34055       if (hlinfo->mouse_face_beg_row == hlinfo->mouse_face_end_row)
 34056         {
 34057           if (hlinfo->mouse_face_beg_col <= hpos && hpos < hlinfo->mouse_face_end_col)
 34058             return true;
 34059         }
 34060       else if ((vpos == hlinfo->mouse_face_beg_row
 34061                 && hpos >= hlinfo->mouse_face_beg_col)
 34062                || (vpos == hlinfo->mouse_face_end_row
 34063                    && hpos < hlinfo->mouse_face_end_col))
 34064         return true;
 34065     }
 34066   else
 34067     {
 34068        if (hlinfo->mouse_face_beg_row == hlinfo->mouse_face_end_row)
 34069         {
 34070           if (hlinfo->mouse_face_end_col < hpos && hpos <= hlinfo->mouse_face_beg_col)
 34071             return true;
 34072         }
 34073       else if ((vpos == hlinfo->mouse_face_beg_row
 34074                 && hpos <= hlinfo->mouse_face_beg_col)
 34075                || (vpos == hlinfo->mouse_face_end_row
 34076                    && hpos > hlinfo->mouse_face_end_col))
 34077         return true;
 34078     }
 34079   return false;
 34080 }
 34081 
 34082 
 34083 /* EXPORT:
 34084    True if physical cursor of window W is within mouse face.  */
 34085 
 34086 bool
 34087 cursor_in_mouse_face_p (struct window *w)
 34088 {
 34089   int vpos = w->phys_cursor.vpos;
 34090 
 34091   /* If the cursor is outside the matrix glyph rows, it cannot be
 34092      within the mouse face.  */
 34093   if (!(0 <= vpos && vpos < w->current_matrix->nrows))
 34094     return false;
 34095 
 34096   int hpos = w->phys_cursor.hpos;
 34097   struct glyph_row *row = MATRIX_ROW (w->current_matrix, vpos);
 34098 
 34099   /* When the window is hscrolled, cursor hpos can legitimately be out
 34100      of bounds, but we draw the cursor at the corresponding window
 34101      margin in that case.  */
 34102   if (!row->reversed_p && hpos < 0)
 34103     hpos = 0;
 34104   if (row->reversed_p && hpos >= row->used[TEXT_AREA])
 34105     hpos = row->used[TEXT_AREA] - 1;
 34106 
 34107   return coords_in_mouse_face_p (w, hpos, vpos);
 34108 }
 34109 
 34110 
 34111 
 34112 /* Find the glyph rows START_ROW and END_ROW of window W that display
 34113    characters between buffer positions START_CHARPOS and END_CHARPOS
 34114    (excluding END_CHARPOS).  DISP_STRING is a display string that
 34115    covers these buffer positions.  This is similar to
 34116    row_containing_pos, but is more accurate when bidi reordering makes
 34117    buffer positions change non-linearly with glyph rows.  */
 34118 static void
 34119 rows_from_pos_range (struct window *w,
 34120                      ptrdiff_t start_charpos, ptrdiff_t end_charpos,
 34121                      Lisp_Object disp_string,
 34122                      struct glyph_row **start, struct glyph_row **end)
 34123 {
 34124   struct glyph_row *first = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 34125   int last_y = window_text_bottom_y (w);
 34126   struct glyph_row *row;
 34127 
 34128   *start = NULL;
 34129   *end = NULL;
 34130 
 34131   while (!first->enabled_p
 34132          && first < MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w))
 34133     first++;
 34134 
 34135   /* Find the START row.  */
 34136   for (row = first;
 34137        row->enabled_p && MATRIX_ROW_BOTTOM_Y (row) <= last_y;
 34138        row++)
 34139     {
 34140       /* A row can potentially be the START row if the range of the
 34141          characters it displays intersects the range
 34142          [START_CHARPOS..END_CHARPOS).  */
 34143       if (! ((start_charpos < MATRIX_ROW_START_CHARPOS (row)
 34144               && end_charpos < MATRIX_ROW_START_CHARPOS (row))
 34145              /* See the commentary in row_containing_pos, for the
 34146                 explanation of the complicated way to check whether
 34147                 some position is beyond the end of the characters
 34148                 displayed by a row.  */
 34149              || ((start_charpos > MATRIX_ROW_END_CHARPOS (row)
 34150                   || (start_charpos == MATRIX_ROW_END_CHARPOS (row)
 34151                       && !row->ends_at_zv_p
 34152                       && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
 34153                  && (end_charpos > MATRIX_ROW_END_CHARPOS (row)
 34154                      || (end_charpos == MATRIX_ROW_END_CHARPOS (row)
 34155                          && !row->ends_at_zv_p
 34156                          && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))))))
 34157         {
 34158           /* Found a candidate row.  Now make sure at least one of the
 34159              glyphs it displays has a charpos from the range
 34160              [START_CHARPOS..END_CHARPOS).
 34161 
 34162              This is not obvious because bidi reordering could make
 34163              buffer positions of a row be 1,2,3,102,101,100, and if we
 34164              want to highlight characters in [50..60), we don't want
 34165              this row, even though [50..60) does intersect [1..103),
 34166              the range of character positions given by the row's start
 34167              and end positions.  */
 34168           struct glyph *g = row->glyphs[TEXT_AREA];
 34169           struct glyph *e = g + row->used[TEXT_AREA];
 34170 
 34171           while (g < e)
 34172             {
 34173               if (((BUFFERP (g->object) || NILP (g->object))
 34174                    && start_charpos <= g->charpos && g->charpos < end_charpos)
 34175                   /* A glyph that comes from DISP_STRING is by
 34176                      definition to be highlighted.  */
 34177                   || EQ (g->object, disp_string))
 34178                 *start = row;
 34179               g++;
 34180             }
 34181           if (*start)
 34182             break;
 34183         }
 34184     }
 34185 
 34186   /* Find the END row.  */
 34187   if (!*start
 34188       /* If the last row is partially visible, start looking for END
 34189          from that row, instead of starting from FIRST.  */
 34190       && !(row->enabled_p
 34191            && row->y < last_y && MATRIX_ROW_BOTTOM_Y (row) > last_y))
 34192     row = first;
 34193   for ( ; row->enabled_p && MATRIX_ROW_BOTTOM_Y (row) <= last_y; row++)
 34194     {
 34195       struct glyph_row *next = row + 1;
 34196       ptrdiff_t next_start = MATRIX_ROW_START_CHARPOS (next);
 34197 
 34198       if (!next->enabled_p
 34199           || next >= MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w)
 34200           /* The first row >= START whose range of displayed characters
 34201              does NOT intersect the range [START_CHARPOS..END_CHARPOS]
 34202              is the row END + 1.  */
 34203           || (start_charpos < next_start
 34204               && end_charpos < next_start)
 34205           || ((start_charpos > MATRIX_ROW_END_CHARPOS (next)
 34206                || (start_charpos == MATRIX_ROW_END_CHARPOS (next)
 34207                    && !next->ends_at_zv_p
 34208                    && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next)))
 34209               && (end_charpos > MATRIX_ROW_END_CHARPOS (next)
 34210                   || (end_charpos == MATRIX_ROW_END_CHARPOS (next)
 34211                       && !next->ends_at_zv_p
 34212                       && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next)))))
 34213         {
 34214           *end = row;
 34215           break;
 34216         }
 34217       else
 34218         {
 34219           /* If the next row's edges intersect [START_CHARPOS..END_CHARPOS],
 34220              but none of the characters it displays are in the range, it is
 34221              also END + 1. */
 34222           struct glyph *g = next->glyphs[TEXT_AREA];
 34223           struct glyph *s = g;
 34224           struct glyph *e = g + next->used[TEXT_AREA];
 34225 
 34226           while (g < e)
 34227             {
 34228               if (((BUFFERP (g->object) || NILP (g->object))
 34229                    && ((start_charpos <= g->charpos && g->charpos < end_charpos)
 34230                        /* If the buffer position of the first glyph in
 34231                           the row is equal to END_CHARPOS, it means
 34232                           the last character to be highlighted is the
 34233                           newline of ROW, and we must consider NEXT as
 34234                           END, not END+1.  */
 34235                        || (((!next->reversed_p && g == s)
 34236                             || (next->reversed_p && g == e - 1))
 34237                            && (g->charpos == end_charpos
 34238                                /* Special case for when NEXT is an
 34239                                   empty line at ZV.  */
 34240                                || (g->charpos == -1
 34241                                    && !row->ends_at_zv_p
 34242                                    && next_start == end_charpos)))))
 34243                   /* A glyph that comes from DISP_STRING is by
 34244                      definition to be highlighted.  */
 34245                   || EQ (g->object, disp_string))
 34246                 break;
 34247               g++;
 34248             }
 34249           if (g == e)
 34250             {
 34251               *end = row;
 34252               break;
 34253             }
 34254           /* The first row that ends at ZV must be the last to be
 34255              highlighted.  */
 34256           else if (next->ends_at_zv_p)
 34257             {
 34258               *end = next;
 34259               break;
 34260             }
 34261         }
 34262     }
 34263 }
 34264 
 34265 /* This function sets the mouse_face_* elements of HLINFO, assuming
 34266    the mouse cursor is on a glyph with buffer charpos MOUSE_CHARPOS in
 34267    window WINDOW.  START_CHARPOS and END_CHARPOS are buffer positions
 34268    for the overlay or run of text properties specifying the mouse
 34269    face.  BEFORE_STRING and AFTER_STRING, if non-nil, are a
 34270    before-string and after-string that must also be highlighted.
 34271    DISP_STRING, if non-nil, is a display string that may cover some
 34272    or all of the highlighted text.  */
 34273 
 34274 static void
 34275 mouse_face_from_buffer_pos (Lisp_Object window,
 34276                             Mouse_HLInfo *hlinfo,
 34277                             ptrdiff_t mouse_charpos,
 34278                             ptrdiff_t start_charpos,
 34279                             ptrdiff_t end_charpos,
 34280                             Lisp_Object before_string,
 34281                             Lisp_Object after_string,
 34282                             Lisp_Object disp_string)
 34283 {
 34284   struct window *w = XWINDOW (window);
 34285   struct glyph_row *first = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 34286   struct glyph_row *r1, *r2;
 34287   struct glyph *glyph, *end;
 34288   ptrdiff_t ignore, pos;
 34289   int x;
 34290 
 34291   eassert (NILP (disp_string) || STRINGP (disp_string));
 34292   eassert (NILP (before_string) || STRINGP (before_string));
 34293   eassert (NILP (after_string) || STRINGP (after_string));
 34294 
 34295   /* Find the rows corresponding to START_CHARPOS and END_CHARPOS.  */
 34296   rows_from_pos_range (w, start_charpos, end_charpos, disp_string, &r1, &r2);
 34297   if (r1 == NULL)
 34298     r1 = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
 34299   /* If the before-string or display-string contains newlines,
 34300      rows_from_pos_range skips to its last row.  Move back.  */
 34301   if (!NILP (before_string) || !NILP (disp_string))
 34302     {
 34303       struct glyph_row *prev;
 34304       while ((prev = r1 - 1, prev >= first)
 34305              && MATRIX_ROW_END_CHARPOS (prev) == start_charpos
 34306              && prev->used[TEXT_AREA] > 0)
 34307         {
 34308           struct glyph *beg = prev->glyphs[TEXT_AREA];
 34309           glyph = beg + prev->used[TEXT_AREA];
 34310           while (--glyph >= beg && NILP (glyph->object));
 34311           if (glyph < beg
 34312               || !(EQ (glyph->object, before_string)
 34313                    || EQ (glyph->object, disp_string)))
 34314             break;
 34315           r1 = prev;
 34316         }
 34317     }
 34318   if (r2 == NULL)
 34319     {
 34320       r2 = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
 34321       hlinfo->mouse_face_past_end = true;
 34322     }
 34323   else if (!NILP (after_string))
 34324     {
 34325       /* If the after-string has newlines, advance to its last row.  */
 34326       struct glyph_row *next;
 34327       struct glyph_row *last
 34328         = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
 34329 
 34330       for (next = r2 + 1;
 34331            next <= last
 34332              && next->used[TEXT_AREA] > 0
 34333              && EQ (next->glyphs[TEXT_AREA]->object, after_string);
 34334            ++next)
 34335         r2 = next;
 34336     }
 34337   /* The rest of the display engine assumes that mouse_face_beg_row is
 34338      either above mouse_face_end_row or identical to it.  But with
 34339      bidi-reordered continued lines, the row for START_CHARPOS could
 34340      be below the row for END_CHARPOS.  If so, swap the rows and store
 34341      them in correct order.  */
 34342   if (r1->y > r2->y)
 34343     {
 34344       struct glyph_row *tem = r2;
 34345 
 34346       r2 = r1;
 34347       r1 = tem;
 34348     }
 34349 
 34350   hlinfo->mouse_face_beg_row = MATRIX_ROW_VPOS (r1, w->current_matrix);
 34351   hlinfo->mouse_face_end_row = MATRIX_ROW_VPOS (r2, w->current_matrix);
 34352 
 34353   /* For a bidi-reordered row, the positions of BEFORE_STRING,
 34354      AFTER_STRING, DISP_STRING, START_CHARPOS, and END_CHARPOS
 34355      could be anywhere in the row and in any order.  The strategy
 34356      below is to find the leftmost and the rightmost glyph that
 34357      belongs to either of these 3 strings, or whose position is
 34358      between START_CHARPOS and END_CHARPOS, and highlight all the
 34359      glyphs between those two.  This may cover more than just the text
 34360      between START_CHARPOS and END_CHARPOS if the range of characters
 34361      strides the bidi level boundary, e.g. if the beginning is in R2L
 34362      text while the end is in L2R text or vice versa.  */
 34363   if (!r1->reversed_p)
 34364     {
 34365       /* This row is in a left to right paragraph.  Scan it left to
 34366          right.  */
 34367       glyph = r1->glyphs[TEXT_AREA];
 34368       end = glyph + r1->used[TEXT_AREA];
 34369       x = r1->x;
 34370 
 34371       /* Skip truncation glyphs at the start of the glyph row.  */
 34372       if (MATRIX_ROW_DISPLAYS_TEXT_P (r1))
 34373         for (; glyph < end
 34374                && NILP (glyph->object)
 34375                && glyph->charpos < 0;
 34376              ++glyph)
 34377           x += glyph->pixel_width;
 34378 
 34379       /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
 34380          or DISP_STRING, and the first glyph from buffer whose
 34381          position is between START_CHARPOS and END_CHARPOS.  */
 34382       for (; glyph < end
 34383              && !NILP (glyph->object)
 34384              && !EQ (glyph->object, disp_string)
 34385              && !(BUFFERP (glyph->object)
 34386                   && (glyph->charpos >= start_charpos
 34387                       && glyph->charpos < end_charpos));
 34388            ++glyph)
 34389         {
 34390           /* BEFORE_STRING or AFTER_STRING are only relevant if they
 34391              are present at buffer positions between START_CHARPOS and
 34392              END_CHARPOS, or if they come from an overlay.  */
 34393           if (EQ (glyph->object, before_string))
 34394             {
 34395               pos = string_buffer_position (before_string,
 34396                                             start_charpos);
 34397               /* If pos == 0, it means before_string came from an
 34398                  overlay, not from a buffer position.  */
 34399               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34400                 break;
 34401             }
 34402           else if (EQ (glyph->object, after_string))
 34403             {
 34404               pos = string_buffer_position (after_string, end_charpos);
 34405               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34406                 break;
 34407             }
 34408           x += glyph->pixel_width;
 34409         }
 34410       hlinfo->mouse_face_beg_x = x;
 34411       hlinfo->mouse_face_beg_col = glyph - r1->glyphs[TEXT_AREA];
 34412     }
 34413   else
 34414     {
 34415       /* This row is in a right to left paragraph.  Scan it right to
 34416          left.  */
 34417       struct glyph *g;
 34418 
 34419       end = r1->glyphs[TEXT_AREA] - 1;
 34420       glyph = end + r1->used[TEXT_AREA];
 34421 
 34422       /* Skip truncation glyphs at the start of the glyph row.  */
 34423       if (MATRIX_ROW_DISPLAYS_TEXT_P (r1))
 34424         for (; glyph > end
 34425                && NILP (glyph->object)
 34426                && glyph->charpos < 0;
 34427              --glyph)
 34428           ;
 34429 
 34430       /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
 34431          or DISP_STRING, and the first glyph from buffer whose
 34432          position is between START_CHARPOS and END_CHARPOS.  */
 34433       for (; glyph > end
 34434              && !NILP (glyph->object)
 34435              && !EQ (glyph->object, disp_string)
 34436              && !(BUFFERP (glyph->object)
 34437                   && (glyph->charpos >= start_charpos
 34438                       && glyph->charpos < end_charpos));
 34439            --glyph)
 34440         {
 34441           /* BEFORE_STRING or AFTER_STRING are only relevant if they
 34442              are present at buffer positions between START_CHARPOS and
 34443              END_CHARPOS, or if they come from an overlay.  */
 34444           if (EQ (glyph->object, before_string))
 34445             {
 34446               pos = string_buffer_position (before_string, start_charpos);
 34447               /* If pos == 0, it means before_string came from an
 34448                  overlay, not from a buffer position.  */
 34449               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34450                 break;
 34451             }
 34452           else if (EQ (glyph->object, after_string))
 34453             {
 34454               pos = string_buffer_position (after_string, end_charpos);
 34455               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34456                 break;
 34457             }
 34458         }
 34459 
 34460       glyph++; /* first glyph to the right of the highlighted area */
 34461       for (g = r1->glyphs[TEXT_AREA], x = r1->x; g < glyph; g++)
 34462         x += g->pixel_width;
 34463       hlinfo->mouse_face_beg_x = x;
 34464       hlinfo->mouse_face_beg_col = glyph - r1->glyphs[TEXT_AREA];
 34465     }
 34466 
 34467   /* If the highlight ends in a different row, compute GLYPH and END
 34468      for the end row.  Otherwise, reuse the values computed above for
 34469      the row where the highlight begins.  */
 34470   if (r2 != r1)
 34471     {
 34472       if (!r2->reversed_p)
 34473         {
 34474           glyph = r2->glyphs[TEXT_AREA];
 34475           end = glyph + r2->used[TEXT_AREA];
 34476           x = r2->x;
 34477         }
 34478       else
 34479         {
 34480           end = r2->glyphs[TEXT_AREA] - 1;
 34481           glyph = end + r2->used[TEXT_AREA];
 34482         }
 34483     }
 34484 
 34485   if (!r2->reversed_p)
 34486     {
 34487       /* Skip truncation and continuation glyphs near the end of the
 34488          row, and also blanks and stretch glyphs inserted by
 34489          extend_face_to_end_of_line.  */
 34490       while (end > glyph
 34491              && NILP ((end - 1)->object))
 34492         --end;
 34493       /* Scan the rest of the glyph row from the end, looking for the
 34494          first glyph that comes from BEFORE_STRING, AFTER_STRING, or
 34495          DISP_STRING, or whose position is between START_CHARPOS
 34496          and END_CHARPOS */
 34497       for (--end;
 34498              end > glyph
 34499              && !NILP (end->object)
 34500              && !EQ (end->object, disp_string)
 34501              && !(BUFFERP (end->object)
 34502                   && (end->charpos >= start_charpos
 34503                       && end->charpos < end_charpos));
 34504            --end)
 34505         {
 34506           /* BEFORE_STRING or AFTER_STRING are only relevant if they
 34507              are present at buffer positions between START_CHARPOS and
 34508              END_CHARPOS, or if they come from an overlay.  */
 34509           if (EQ (end->object, before_string))
 34510             {
 34511               pos = string_buffer_position (before_string, start_charpos);
 34512               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34513                 break;
 34514             }
 34515           else if (EQ (end->object, after_string))
 34516             {
 34517               pos = string_buffer_position (after_string, end_charpos);
 34518               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34519                 break;
 34520             }
 34521         }
 34522       /* Find the X coordinate of the last glyph to be highlighted.  */
 34523       for (; glyph <= end; ++glyph)
 34524         x += glyph->pixel_width;
 34525 
 34526       hlinfo->mouse_face_end_x = x;
 34527       hlinfo->mouse_face_end_col = glyph - r2->glyphs[TEXT_AREA];
 34528     }
 34529   else
 34530     {
 34531       /* Skip truncation and continuation glyphs near the end of the
 34532          row, and also blanks and stretch glyphs inserted by
 34533          extend_face_to_end_of_line.  */
 34534       x = r2->x;
 34535       end++;
 34536       while (end < glyph
 34537              && NILP (end->object))
 34538         {
 34539           x += end->pixel_width;
 34540           ++end;
 34541         }
 34542       /* Scan the rest of the glyph row from the end, looking for the
 34543          first glyph that comes from BEFORE_STRING, AFTER_STRING, or
 34544          DISP_STRING, or whose position is between START_CHARPOS
 34545          and END_CHARPOS */
 34546       for ( ;
 34547              end < glyph
 34548              && !NILP (end->object)
 34549              && !EQ (end->object, disp_string)
 34550              && !(BUFFERP (end->object)
 34551                   && (end->charpos >= start_charpos
 34552                       && end->charpos < end_charpos));
 34553            ++end)
 34554         {
 34555           /* BEFORE_STRING or AFTER_STRING are only relevant if they
 34556              are present at buffer positions between START_CHARPOS and
 34557              END_CHARPOS, or if they come from an overlay.  */
 34558           if (EQ (end->object, before_string))
 34559             {
 34560               pos = string_buffer_position (before_string, start_charpos);
 34561               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34562                 break;
 34563             }
 34564           else if (EQ (end->object, after_string))
 34565             {
 34566               pos = string_buffer_position (after_string, end_charpos);
 34567               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34568                 break;
 34569             }
 34570           x += end->pixel_width;
 34571         }
 34572       /* If we exited the above loop because we arrived at the last
 34573          glyph of the row, and its buffer position is still not in
 34574          range, it means the last character in range is the preceding
 34575          newline.  Bump the end column and x values to get past the
 34576          last glyph.  */
 34577       if (end == glyph
 34578           && BUFFERP (end->object)
 34579           && (end->charpos < start_charpos
 34580               || end->charpos >= end_charpos))
 34581         {
 34582           x += end->pixel_width;
 34583           ++end;
 34584         }
 34585       hlinfo->mouse_face_end_x = x;
 34586       hlinfo->mouse_face_end_col = end - r2->glyphs[TEXT_AREA];
 34587     }
 34588 
 34589   hlinfo->mouse_face_window = window;
 34590   hlinfo->mouse_face_face_id
 34591     = face_at_buffer_position (w, mouse_charpos, &ignore,
 34592                                mouse_charpos + 1,
 34593                                !hlinfo->mouse_face_hidden, -1, 0);
 34594   show_mouse_face (hlinfo, DRAW_MOUSE_FACE);
 34595 }
 34596 
 34597 /* The following function is not used anymore (replaced with
 34598    mouse_face_from_string_pos), but I leave it here for the time
 34599    being, in case someone would.  */
 34600 
 34601 #if false       /* not used */
 34602 
 34603 /* Find the position of the glyph for position POS in OBJECT in
 34604    window W's current matrix, and return in *X, *Y the pixel
 34605    coordinates, and return in *HPOS, *VPOS the column/row of the glyph.
 34606 
 34607    RIGHT_P means return the position of the right edge of the glyph.
 34608    !RIGHT_P means return the left edge position.
 34609 
 34610    If no glyph for POS exists in the matrix, return the position of
 34611    the glyph with the next smaller position that is in the matrix, if
 34612    RIGHT_P is false.  If RIGHT_P, and no glyph for POS
 34613    exists in the matrix, return the position of the glyph with the
 34614    next larger position in OBJECT.
 34615 
 34616    Value is true if a glyph was found.  */
 34617 
 34618 static bool
 34619 fast_find_string_pos (struct window *w, ptrdiff_t pos, Lisp_Object object,
 34620                       int *hpos, int *vpos, int *x, int *y, bool right_p)
 34621 {
 34622   int yb = window_text_bottom_y (w);
 34623   struct glyph_row *r;
 34624   struct glyph *best_glyph = NULL;
 34625   struct glyph_row *best_row = NULL;
 34626   int best_x = 0;
 34627 
 34628   for (r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 34629        r->enabled_p && r->y < yb;
 34630        ++r)
 34631     {
 34632       struct glyph *g = r->glyphs[TEXT_AREA];
 34633       struct glyph *e = g + r->used[TEXT_AREA];
 34634       int gx;
 34635 
 34636       for (gx = r->x; g < e; gx += g->pixel_width, ++g)
 34637         if (EQ (g->object, object))
 34638           {
 34639             if (g->charpos == pos)
 34640               {
 34641                 best_glyph = g;
 34642                 best_x = gx;
 34643                 best_row = r;
 34644                 goto found;
 34645               }
 34646             else if (best_glyph == NULL
 34647                      || ((eabs (g->charpos - pos)
 34648                          < eabs (best_glyph->charpos - pos))
 34649                          && (right_p
 34650                              ? g->charpos < pos
 34651                              : g->charpos > pos)))
 34652               {
 34653                 best_glyph = g;
 34654                 best_x = gx;
 34655                 best_row = r;
 34656               }
 34657           }
 34658     }
 34659 
 34660  found:
 34661 
 34662   if (best_glyph)
 34663     {
 34664       *x = best_x;
 34665       *hpos = best_glyph - best_row->glyphs[TEXT_AREA];
 34666 
 34667       if (right_p)
 34668         {
 34669           *x += best_glyph->pixel_width;
 34670           ++*hpos;
 34671         }
 34672 
 34673       *y = best_row->y;
 34674       *vpos = MATRIX_ROW_VPOS (best_row, w->current_matrix);
 34675     }
 34676 
 34677   return best_glyph != NULL;
 34678 }
 34679 #endif  /* not used */
 34680 
 34681 /* Find the positions of the first and the last glyphs in window W's
 34682    current matrix that occlude positions [STARTPOS..ENDPOS) in OBJECT
 34683    (assumed to be a string), and return in HLINFO's mouse_face_*
 34684    members the pixel and column/row coordinates of those glyphs.  */
 34685 
 34686 static void
 34687 mouse_face_from_string_pos (struct window *w, Mouse_HLInfo *hlinfo,
 34688                             Lisp_Object object,
 34689                             ptrdiff_t startpos, ptrdiff_t endpos)
 34690 {
 34691   int yb = window_text_bottom_y (w);
 34692   struct glyph_row *r;
 34693   struct glyph *g, *e;
 34694   int gx;
 34695   bool found = false;
 34696 
 34697   /* Find the glyph row with at least one position in the range
 34698      [STARTPOS..ENDPOS), and the first glyph in that row whose
 34699      position belongs to that range.  */
 34700   for (r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 34701        r->enabled_p && r->y < yb;
 34702        ++r)
 34703     {
 34704       if (!r->reversed_p)
 34705         {
 34706           g = r->glyphs[TEXT_AREA];
 34707           e = g + r->used[TEXT_AREA];
 34708           for (gx = r->x; g < e; gx += g->pixel_width, ++g)
 34709             if (EQ (g->object, object)
 34710                 && startpos <= g->charpos && g->charpos < endpos)
 34711               {
 34712                 hlinfo->mouse_face_beg_row
 34713                   = MATRIX_ROW_VPOS (r, w->current_matrix);
 34714                 hlinfo->mouse_face_beg_col = g - r->glyphs[TEXT_AREA];
 34715                 hlinfo->mouse_face_beg_x = gx;
 34716                 found = true;
 34717                 break;
 34718               }
 34719         }
 34720       else
 34721         {
 34722           struct glyph *g1;
 34723 
 34724           e = r->glyphs[TEXT_AREA];
 34725           g = e + r->used[TEXT_AREA];
 34726           for ( ; g > e; --g)
 34727             if (EQ ((g-1)->object, object)
 34728                 && startpos <= (g-1)->charpos && (g-1)->charpos < endpos)
 34729               {
 34730                 hlinfo->mouse_face_beg_row
 34731                   = MATRIX_ROW_VPOS (r, w->current_matrix);
 34732                 hlinfo->mouse_face_beg_col = g - r->glyphs[TEXT_AREA];
 34733                 for (gx = r->x, g1 = r->glyphs[TEXT_AREA]; g1 < g; ++g1)
 34734                   gx += g1->pixel_width;
 34735                 hlinfo->mouse_face_beg_x = gx;
 34736                 found = true;
 34737                 break;
 34738               }
 34739         }
 34740       if (found)
 34741         break;
 34742     }
 34743 
 34744   if (!found)
 34745     return;
 34746 
 34747   /* Starting with the next row, look for the first row which does NOT
 34748      include any glyphs whose positions are in the range.  */
 34749   for (++r; r->enabled_p && r->y < yb; ++r)
 34750     {
 34751       g = r->glyphs[TEXT_AREA];
 34752       e = g + r->used[TEXT_AREA];
 34753       found = false;
 34754       for ( ; g < e; ++g)
 34755         if (EQ (g->object, object)
 34756             && startpos <= g->charpos && g->charpos < endpos)
 34757           {
 34758             found = true;
 34759             break;
 34760           }
 34761       if (!found)
 34762         break;
 34763     }
 34764 
 34765   /* The highlighted region ends on the previous row.  */
 34766   r--;
 34767 
 34768   /* Set the end row.  */
 34769   hlinfo->mouse_face_end_row = MATRIX_ROW_VPOS (r, w->current_matrix);
 34770 
 34771   /* Compute and set the end column and the end column's horizontal
 34772      pixel coordinate.  */
 34773   if (!r->reversed_p)
 34774     {
 34775       g = r->glyphs[TEXT_AREA];
 34776       e = g + r->used[TEXT_AREA];
 34777       for ( ; e > g; --e)
 34778         if (EQ ((e-1)->object, object)
 34779             && startpos <= (e-1)->charpos && (e-1)->charpos < endpos)
 34780           break;
 34781       hlinfo->mouse_face_end_col = e - g;
 34782 
 34783       for (gx = r->x; g < e; ++g)
 34784         gx += g->pixel_width;
 34785       hlinfo->mouse_face_end_x = gx;
 34786     }
 34787   else
 34788     {
 34789       e = r->glyphs[TEXT_AREA];
 34790       g = e + r->used[TEXT_AREA];
 34791       for (gx = r->x ; e < g; ++e)
 34792         {
 34793           if (EQ (e->object, object)
 34794               && startpos <= e->charpos && e->charpos < endpos)
 34795             break;
 34796           gx += e->pixel_width;
 34797         }
 34798       hlinfo->mouse_face_end_col = e - r->glyphs[TEXT_AREA];
 34799       hlinfo->mouse_face_end_x = gx;
 34800     }
 34801 }
 34802 
 34803 #ifdef HAVE_WINDOW_SYSTEM
 34804 
 34805 /* See if position X, Y is within a hot-spot of an image.  */
 34806 
 34807 static bool
 34808 on_hot_spot_p (Lisp_Object hot_spot, int x, int y)
 34809 {
 34810   if (!CONSP (hot_spot))
 34811     return false;
 34812 
 34813   if (EQ (XCAR (hot_spot), Qrect))
 34814     {
 34815       /* CDR is (Top-Left . Bottom-Right) = ((x0 . y0) . (x1 . y1))  */
 34816       Lisp_Object rect = XCDR (hot_spot);
 34817       Lisp_Object tem;
 34818       if (!CONSP (rect))
 34819         return false;
 34820       if (!CONSP (XCAR (rect)))
 34821         return false;
 34822       if (!CONSP (XCDR (rect)))
 34823         return false;
 34824       if (!(tem = XCAR (XCAR (rect)), FIXNUMP (tem) && x >= XFIXNUM (tem)))
 34825         return false;
 34826       if (!(tem = XCDR (XCAR (rect)), FIXNUMP (tem) && y >= XFIXNUM (tem)))
 34827         return false;
 34828       if (!(tem = XCAR (XCDR (rect)), FIXNUMP (tem) && x <= XFIXNUM (tem)))
 34829         return false;
 34830       if (!(tem = XCDR (XCDR (rect)), FIXNUMP (tem) && y <= XFIXNUM (tem)))
 34831         return false;
 34832       return true;
 34833     }
 34834   else if (EQ (XCAR (hot_spot), Qcircle))
 34835     {
 34836       /* CDR is (Center . Radius) = ((x0 . y0) . r) */
 34837       Lisp_Object circ = XCDR (hot_spot);
 34838       Lisp_Object lr, lx0, ly0;
 34839       if (CONSP (circ)
 34840           && CONSP (XCAR (circ))
 34841           && (lr = XCDR (circ), NUMBERP (lr))
 34842           && (lx0 = XCAR (XCAR (circ)), FIXNUMP (lx0))
 34843           && (ly0 = XCDR (XCAR (circ)), FIXNUMP (ly0)))
 34844         {
 34845           double r = XFLOATINT (lr);
 34846           double dx = XFIXNUM (lx0) - x;
 34847           double dy = XFIXNUM (ly0) - y;
 34848           return (dx * dx + dy * dy <= r * r);
 34849         }
 34850     }
 34851   else if (EQ (XCAR (hot_spot), Qpoly))
 34852     {
 34853       /* CDR is [x0 y0 x1 y1 x2 y2 ...x(n-1) y(n-1)] */
 34854       if (VECTORP (XCDR (hot_spot)))
 34855         {
 34856           struct Lisp_Vector *v = XVECTOR (XCDR (hot_spot));
 34857           Lisp_Object *poly = v->contents;
 34858           ptrdiff_t n = v->header.size;
 34859           ptrdiff_t i;
 34860           bool inside = false;
 34861           Lisp_Object lx, ly;
 34862           int x0, y0;
 34863 
 34864           /* Need an even number of coordinates, and at least 3 edges.  */
 34865           if (n < 6 || n & 1)
 34866             return false;
 34867 
 34868           /* Count edge segments intersecting line from (X,Y) to (X,infinity).
 34869              If count is odd, we are inside polygon.  Pixels on edges
 34870              may or may not be included depending on actual geometry of the
 34871              polygon.  */
 34872           if ((lx = poly[n-2], !FIXNUMP (lx))
 34873               || (ly = poly[n-1], !FIXNUMP (lx)))
 34874             return false;
 34875           x0 = XFIXNUM (lx), y0 = XFIXNUM (ly);
 34876           for (i = 0; i < n; i += 2)
 34877             {
 34878               int x1 = x0, y1 = y0;
 34879               if ((lx = poly[i], !FIXNUMP (lx))
 34880                   || (ly = poly[i+1], !FIXNUMP (ly)))
 34881                 return false;
 34882               x0 = XFIXNUM (lx), y0 = XFIXNUM (ly);
 34883 
 34884               /* Does this segment cross the X line?  */
 34885               if (x0 >= x)
 34886                 {
 34887                   if (x1 >= x)
 34888                     continue;
 34889                 }
 34890               else if (x1 < x)
 34891                 continue;
 34892               if (y > y0 && y > y1)
 34893                 continue;
 34894               if (y < y0 + ((y1 - y0) * (x - x0)) / (x1 - x0))
 34895                 inside = !inside;
 34896             }
 34897           return inside;
 34898         }
 34899     }
 34900   return false;
 34901 }
 34902 
 34903 Lisp_Object
 34904 find_hot_spot (Lisp_Object map, int x, int y)
 34905 {
 34906   while (CONSP (map))
 34907     {
 34908       if (CONSP (XCAR (map))
 34909           && on_hot_spot_p (XCAR (XCAR (map)), x, y))
 34910         return XCAR (map);
 34911       map = XCDR (map);
 34912     }
 34913 
 34914   return Qnil;
 34915 }
 34916 
 34917 DEFUN ("lookup-image-map", Flookup_image_map, Slookup_image_map,
 34918        3, 3, 0,
 34919        doc: /* Lookup in image map MAP coordinates X and Y.
 34920 An image map is an alist where each element has the format (AREA ID PLIST).
 34921 An AREA is specified as either a rectangle, a circle, or a polygon:
 34922 A rectangle is a cons (rect . ((x0 . y0) . (x1 . y1))) specifying the
 34923 pixel coordinates of the upper left and bottom right corners.
 34924 A circle is a cons (circle . ((x0 . y0) . r)) specifying the center
 34925 and the radius of the circle; r may be a float or integer.
 34926 A polygon is a cons (poly . [x0 y0 x1 y1 ...]) where each pair in the
 34927 vector describes one corner in the polygon.
 34928 Returns the alist element for the first matching AREA in MAP.  */)
 34929   (Lisp_Object map, Lisp_Object x, Lisp_Object y)
 34930 {
 34931   if (NILP (map))
 34932     return Qnil;
 34933 
 34934   CHECK_FIXNUM (x);
 34935   CHECK_FIXNUM (y);
 34936 
 34937   return find_hot_spot (map,
 34938                         clip_to_bounds (INT_MIN, XFIXNUM (x), INT_MAX),
 34939                         clip_to_bounds (INT_MIN, XFIXNUM (y), INT_MAX));
 34940 }
 34941 #endif  /* HAVE_WINDOW_SYSTEM */
 34942 
 34943 
 34944 /* Display frame CURSOR, optionally using shape defined by POINTER.  */
 34945 static void
 34946 define_frame_cursor1 (struct frame *f, Emacs_Cursor cursor, Lisp_Object pointer)
 34947 {
 34948 #ifdef HAVE_WINDOW_SYSTEM
 34949   if (!FRAME_WINDOW_P (f))
 34950     return;
 34951 
 34952   /* Do not change cursor shape while dragging mouse.  */
 34953   if (EQ (track_mouse, Qdragging) || EQ (track_mouse, Qdropping)
 34954       || EQ (track_mouse, Qdrag_source))
 34955     return;
 34956 
 34957   if (!NILP (pointer))
 34958     {
 34959       if (EQ (pointer, Qarrow))
 34960         cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 34961       else if (EQ (pointer, Qhand))
 34962         cursor = FRAME_OUTPUT_DATA (f)->hand_cursor;
 34963       else if (EQ (pointer, Qtext))
 34964         cursor = FRAME_OUTPUT_DATA (f)->text_cursor;
 34965       else if (EQ (pointer, intern ("hdrag")))
 34966         cursor = FRAME_OUTPUT_DATA (f)->horizontal_drag_cursor;
 34967       else if (EQ (pointer, intern ("nhdrag")))
 34968         cursor = FRAME_OUTPUT_DATA (f)->vertical_drag_cursor;
 34969 # ifdef HAVE_X_WINDOWS
 34970       else if (EQ (pointer, intern ("vdrag")))
 34971         cursor = FRAME_DISPLAY_INFO (f)->vertical_scroll_bar_cursor;
 34972 # endif
 34973       else if (EQ (pointer, intern ("hourglass")))
 34974         cursor = FRAME_OUTPUT_DATA (f)->hourglass_cursor;
 34975       else if (EQ (pointer, Qmodeline))
 34976         cursor = FRAME_OUTPUT_DATA (f)->modeline_cursor;
 34977       else
 34978         cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 34979     }
 34980 
 34981   if (cursor != No_Cursor)
 34982     FRAME_RIF (f)->define_frame_cursor (f, cursor);
 34983 #endif
 34984 }
 34985 
 34986 /* Take proper action when mouse has moved to the mode or header line
 34987    or marginal area AREA of window W, x-position X and y-position Y.
 34988    X is relative to the start of the text display area of W, so the
 34989    width of bitmap areas and scroll bars must be subtracted to get a
 34990    position relative to the start of the mode line.  */
 34991 
 34992 static void
 34993 note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y,
 34994                                     enum window_part area)
 34995 {
 34996   struct window *w = XWINDOW (window);
 34997   struct frame *f = XFRAME (w->frame);
 34998   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 34999   Emacs_Cursor cursor = No_Cursor;
 35000   Lisp_Object pointer = Qnil;
 35001   int dx, dy, width, height;
 35002   ptrdiff_t charpos;
 35003   Lisp_Object string, object = Qnil;
 35004   Lisp_Object pos UNINIT;
 35005   Lisp_Object mouse_face;
 35006   int original_x_pixel = x;
 35007   struct glyph * glyph = NULL, * row_start_glyph = NULL;
 35008   struct glyph_row *row UNINIT;
 35009 
 35010   if (area == ON_MODE_LINE || area == ON_HEADER_LINE || area == ON_TAB_LINE)
 35011     {
 35012       int x0;
 35013       struct glyph *end;
 35014 
 35015       /* Kludge alert: mode_line_string takes X/Y in pixels, but
 35016          returns them in row/column units!  */
 35017       string = mode_line_string (w, area, &x, &y, &charpos,
 35018                                  &object, &dx, &dy, &width, &height);
 35019 
 35020       row = (area == ON_MODE_LINE
 35021              ? MATRIX_MODE_LINE_ROW (w->current_matrix)
 35022              : (area == ON_TAB_LINE
 35023                 ? MATRIX_TAB_LINE_ROW (w->current_matrix)
 35024                 : MATRIX_HEADER_LINE_ROW (w->current_matrix)));
 35025 
 35026       /* Find the glyph under the mouse pointer.  */
 35027       if (row->mode_line_p && row->enabled_p)
 35028         {
 35029           glyph = row_start_glyph = row->glyphs[TEXT_AREA];
 35030           end = glyph + row->used[TEXT_AREA];
 35031 
 35032           for (x0 = original_x_pixel;
 35033                glyph < end && x0 >= glyph->pixel_width;
 35034                ++glyph)
 35035             x0 -= glyph->pixel_width;
 35036 
 35037           if (glyph >= end)
 35038             glyph = NULL;
 35039         }
 35040     }
 35041   else
 35042     {
 35043       x -= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w);
 35044       /* Kludge alert: marginal_area_string takes X/Y in pixels, but
 35045          returns them in row/column units!  */
 35046       string = marginal_area_string (w, area, &x, &y, &charpos,
 35047                                      &object, &dx, &dy, &width, &height);
 35048     }
 35049 
 35050   Lisp_Object help = Qnil;
 35051 
 35052 #ifdef HAVE_WINDOW_SYSTEM
 35053   if (IMAGEP (object))
 35054     {
 35055       Lisp_Object image_map, hotspot;
 35056       if ((image_map = plist_get (XCDR (object), QCmap),
 35057            !NILP (image_map))
 35058           && (hotspot = find_hot_spot (image_map, dx, dy),
 35059               CONSP (hotspot))
 35060           && (hotspot = XCDR (hotspot), CONSP (hotspot)))
 35061         {
 35062           Lisp_Object plist;
 35063 
 35064           /* Could check XCAR (hotspot) to see if we enter/leave this hot-spot.
 35065              If so, we could look for mouse-enter, mouse-leave
 35066              properties in PLIST (and do something...).  */
 35067           hotspot = XCDR (hotspot);
 35068           if (CONSP (hotspot)
 35069               && (plist = XCAR (hotspot), CONSP (plist)))
 35070             {
 35071               pointer = plist_get (plist, Qpointer);
 35072               if (NILP (pointer))
 35073                 pointer = Qhand;
 35074               help = plist_get (plist, Qhelp_echo);
 35075               if (!NILP (help))
 35076                 {
 35077                   help_echo_string = help;
 35078                   XSETWINDOW (help_echo_window, w);
 35079                   help_echo_object = w->contents;
 35080                   help_echo_pos = charpos;
 35081                 }
 35082             }
 35083         }
 35084       if (NILP (pointer))
 35085         pointer = plist_get (XCDR (object), QCpointer);
 35086     }
 35087 #endif  /* HAVE_WINDOW_SYSTEM */
 35088 
 35089   /* CHARPOS can be beyond the last position of STRING due, e.g., to
 35090      min-width 'display' property.  Fix that, to let all the calls to
 35091      get-text-property below do their thing.  */
 35092   if (STRINGP (string))
 35093     pos = make_fixnum (min (charpos, SCHARS (string) - 1));
 35094 
 35095   /* Set the help text and mouse pointer.  If the mouse is on a part
 35096      of the mode line without any text (e.g. past the right edge of
 35097      the mode line text), use that windows's mode line help echo if it
 35098      has been set.  */
 35099   if (STRINGP (string) || area == ON_MODE_LINE || area == ON_HEADER_LINE
 35100       || area == ON_TAB_LINE)
 35101     {
 35102       /* Arrange to display the help by setting the global variables
 35103          help_echo_string, help_echo_object, and help_echo_pos.  */
 35104       if (NILP (help))
 35105         {
 35106           if (STRINGP (string))
 35107             help = Fget_text_property (pos, Qhelp_echo, string);
 35108 
 35109           if (!NILP (help))
 35110             {
 35111               help_echo_string = help;
 35112               XSETWINDOW (help_echo_window, w);
 35113               help_echo_object = string;
 35114               help_echo_pos = charpos;
 35115             }
 35116           else if (area == ON_MODE_LINE
 35117                    && !NILP (w->mode_line_help_echo))
 35118             {
 35119               help_echo_string =  w->mode_line_help_echo;
 35120               XSETWINDOW (help_echo_window, w);
 35121               help_echo_object = Qnil;
 35122               help_echo_pos = -1;
 35123             }
 35124         }
 35125 
 35126 #ifdef HAVE_WINDOW_SYSTEM
 35127       /* Change the mouse pointer according to what is under it.  */
 35128       if (FRAME_WINDOW_P (f))
 35129         {
 35130           bool draggable = (! WINDOW_BOTTOMMOST_P (w)
 35131                             || minibuf_level
 35132                             || NILP (Vresize_mini_windows));
 35133 
 35134           if (STRINGP (string))
 35135             {
 35136               cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35137 
 35138               if (NILP (pointer))
 35139                 pointer = Fget_text_property (pos, Qpointer, string);
 35140 
 35141               /* Change the mouse pointer according to what is under X/Y.  */
 35142               if (NILP (pointer)
 35143                   && (area == ON_MODE_LINE || area == ON_HEADER_LINE
 35144                       || area == ON_TAB_LINE))
 35145                 {
 35146                   Lisp_Object map;
 35147 
 35148                   map = Fget_text_property (pos, Qlocal_map, string);
 35149                   if (!KEYMAPP (map))
 35150                     map = Fget_text_property (pos, Qkeymap, string);
 35151                   if (!KEYMAPP (map) && draggable && area == ON_MODE_LINE)
 35152                     cursor = FRAME_OUTPUT_DATA (f)->vertical_drag_cursor;
 35153                 }
 35154             }
 35155           else if (draggable && area == ON_MODE_LINE)
 35156             cursor = FRAME_OUTPUT_DATA (f)->vertical_drag_cursor;
 35157           else if ((area == ON_MODE_LINE
 35158                     && WINDOW_BOTTOMMOST_P (w)
 35159                     && !FRAME_HAS_MINIBUF_P (f)
 35160                     && !NILP (Fframe_parameter
 35161                               (w->frame, Qdrag_with_mode_line)))
 35162                    || (((area == ON_HEADER_LINE
 35163                          && !NILP (Fframe_parameter
 35164                                    (w->frame, Qdrag_with_header_line)))
 35165                         || (area == ON_TAB_LINE
 35166                             && !NILP (Fframe_parameter
 35167                                       (w->frame, Qdrag_with_tab_line))))
 35168                        && WINDOW_TOPMOST_P (w)))
 35169             cursor = FRAME_OUTPUT_DATA (f)->hand_cursor;
 35170           else
 35171             cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35172         }
 35173 #endif
 35174     }
 35175 
 35176   /* Change the mouse face according to what is under X/Y.  */
 35177   bool mouse_face_shown = false;
 35178 
 35179   if (STRINGP (string))
 35180     {
 35181       mouse_face = Fget_text_property (pos, Qmouse_face, string);
 35182       if (!NILP (Vmouse_highlight) && !NILP (mouse_face)
 35183           && ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE)
 35184               || (area == ON_TAB_LINE))
 35185           && glyph)
 35186         {
 35187           Lisp_Object b, e;
 35188 
 35189           struct glyph * tmp_glyph;
 35190 
 35191           int gpos;
 35192           int gseq_length;
 35193           int total_pixel_width;
 35194           ptrdiff_t begpos, endpos, ignore;
 35195 
 35196           int vpos, hpos;
 35197 
 35198           b = Fprevious_single_property_change (make_fixnum (charpos + 1),
 35199                                                 Qmouse_face, string, Qnil);
 35200           if (NILP (b))
 35201             begpos = 0;
 35202           else
 35203             begpos = XFIXNUM (b);
 35204 
 35205           e = Fnext_single_property_change (pos, Qmouse_face, string, Qnil);
 35206           if (NILP (e))
 35207             endpos = SCHARS (string);
 35208           else
 35209             endpos = XFIXNUM (e);
 35210 
 35211           /* Calculate the glyph position GPOS of GLYPH in the
 35212              displayed string, relative to the beginning of the
 35213              highlighted part of the string.
 35214 
 35215              Note: GPOS is different from CHARPOS.  CHARPOS is the
 35216              position of GLYPH in the internal string object.  A mode
 35217              line string format has structures which are converted to
 35218              a flattened string by the Emacs Lisp interpreter.  The
 35219              internal string is an element of those structures.  The
 35220              displayed string is the flattened string.  */
 35221           tmp_glyph = row_start_glyph;
 35222           while (tmp_glyph < glyph
 35223                  && (!(EQ (tmp_glyph->object, glyph->object)
 35224                        && begpos <= tmp_glyph->charpos
 35225                        && tmp_glyph->charpos < endpos)))
 35226             tmp_glyph++;
 35227           gpos = glyph - tmp_glyph;
 35228 
 35229           /* Calculate the length GSEQ_LENGTH of the glyph sequence of
 35230              the highlighted part of the displayed string to which
 35231              GLYPH belongs.  Note: GSEQ_LENGTH is different from
 35232              SCHARS (STRING), because the latter returns the length of
 35233              the internal string.  */
 35234           for (tmp_glyph = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
 35235                tmp_glyph > glyph
 35236                  && (!(EQ (tmp_glyph->object, glyph->object)
 35237                        && begpos <= tmp_glyph->charpos
 35238                        && tmp_glyph->charpos < endpos));
 35239                tmp_glyph--)
 35240             ;
 35241           gseq_length = gpos + (tmp_glyph - glyph) + 1;
 35242 
 35243           /* Calculate the total pixel width of all the glyphs between
 35244              the beginning of the highlighted area and GLYPH.  */
 35245           total_pixel_width = 0;
 35246           for (tmp_glyph = glyph - gpos; tmp_glyph != glyph; tmp_glyph++)
 35247             total_pixel_width += tmp_glyph->pixel_width;
 35248 
 35249           /* Pre calculation of re-rendering position.  Note: X is in
 35250              column units here, after the call to mode_line_string or
 35251              marginal_area_string.  */
 35252           hpos = x - gpos;
 35253           vpos = (area == ON_MODE_LINE
 35254                   ? (w->current_matrix)->nrows - 1
 35255                   : (area == ON_TAB_LINE
 35256                      ? 0
 35257                      : (w->current_matrix->tab_line_p
 35258                         ? 1
 35259                         : 0)));
 35260 
 35261           /* If GLYPH's position is included in the region that is
 35262              already drawn in mouse face, we have nothing to do.  */
 35263           if ( EQ (window, hlinfo->mouse_face_window)
 35264                && (!row->reversed_p
 35265                    ? (hlinfo->mouse_face_beg_col <= hpos
 35266                       && hpos < hlinfo->mouse_face_end_col)
 35267                    /* In R2L rows we swap BEG and END, see below.  */
 35268                    : (hlinfo->mouse_face_end_col <= hpos
 35269                       && hpos < hlinfo->mouse_face_beg_col))
 35270                && hlinfo->mouse_face_beg_row == vpos )
 35271             return;
 35272 
 35273           if (clear_mouse_face (hlinfo))
 35274             cursor = No_Cursor;
 35275 
 35276           if (!row->reversed_p)
 35277             {
 35278               hlinfo->mouse_face_beg_col = hpos;
 35279               hlinfo->mouse_face_beg_x   = original_x_pixel
 35280                                             - (total_pixel_width + dx);
 35281               hlinfo->mouse_face_end_col = hpos + gseq_length;
 35282               hlinfo->mouse_face_end_x   = 0;
 35283             }
 35284           else
 35285             {
 35286               /* In R2L rows, show_mouse_face expects BEG and END
 35287                  coordinates to be swapped.  */
 35288               hlinfo->mouse_face_end_col = hpos;
 35289               hlinfo->mouse_face_end_x   = original_x_pixel
 35290                                             - (total_pixel_width + dx);
 35291               hlinfo->mouse_face_beg_col = hpos + gseq_length;
 35292               hlinfo->mouse_face_beg_x   = 0;
 35293             }
 35294 
 35295           hlinfo->mouse_face_beg_row  = vpos;
 35296           hlinfo->mouse_face_end_row  = hlinfo->mouse_face_beg_row;
 35297           hlinfo->mouse_face_past_end = false;
 35298           hlinfo->mouse_face_window   = window;
 35299 
 35300           hlinfo->mouse_face_face_id =
 35301             face_at_string_position (w, string, charpos, 0, &ignore,
 35302                                      glyph->face_id, true, 0);
 35303 
 35304           show_mouse_face (hlinfo, DRAW_MOUSE_FACE);
 35305           mouse_face_shown = true;
 35306 
 35307           if (NILP (pointer))
 35308             pointer = Qhand;
 35309         }
 35310     }
 35311 
 35312   /* If mouse-face doesn't need to be shown, clear any existing
 35313      mouse-face.  */
 35314   if ((area == ON_MODE_LINE || area == ON_HEADER_LINE
 35315        || area == ON_TAB_LINE) && !mouse_face_shown)
 35316     clear_mouse_face (hlinfo);
 35317 
 35318   define_frame_cursor1 (f, cursor, pointer);
 35319 }
 35320 
 35321 
 35322 /* EXPORT:
 35323    Take proper action when the mouse has moved to position X, Y on
 35324    frame F with regards to highlighting portions of display that have
 35325    mouse-face properties.  Also de-highlight portions of display where
 35326    the mouse was before, set the mouse pointer shape as appropriate
 35327    for the mouse coordinates, and activate help echo (tooltips).
 35328    X and Y can be negative or out of range.  */
 35329 
 35330 void
 35331 note_mouse_highlight (struct frame *f, int x, int y)
 35332 {
 35333   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 35334   enum window_part part = ON_NOTHING;
 35335   Lisp_Object window;
 35336   struct window *w;
 35337   Emacs_Cursor cursor = No_Cursor;
 35338   Lisp_Object pointer = Qnil;  /* Takes precedence over cursor!  */
 35339   struct buffer *b;
 35340 
 35341   /* When a menu is active, don't highlight because this looks odd.  */
 35342 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NS) || defined (MSDOS) \
 35343   || defined (HAVE_ANDROID)
 35344   if (popup_activated ())
 35345     return;
 35346 #endif
 35347 
 35348 #if defined (HAVE_HAIKU)
 35349   if (popup_activated_p)
 35350     return;
 35351 #endif
 35352 
 35353   if (!f->glyphs_initialized_p
 35354       || f->pointer_invisible)
 35355     return;
 35356 
 35357   hlinfo->mouse_face_mouse_x = x;
 35358   hlinfo->mouse_face_mouse_y = y;
 35359   hlinfo->mouse_face_mouse_frame = f;
 35360 
 35361   if (hlinfo->mouse_face_defer)
 35362     return;
 35363 
 35364   /* Which window is that in?  */
 35365   window = window_from_coordinates (f, x, y, &part, true, true);
 35366 
 35367   /* If displaying active text in another window, clear that.  */
 35368   if (! EQ (window, hlinfo->mouse_face_window)
 35369       /* Also clear if we move out of text area in same window.  */
 35370       || (!NILP (hlinfo->mouse_face_window)
 35371           && !NILP (window)
 35372           && part != ON_TEXT
 35373           && part != ON_MODE_LINE
 35374           && part != ON_HEADER_LINE
 35375           && part != ON_TAB_LINE))
 35376     clear_mouse_face (hlinfo);
 35377 
 35378   /* Reset help_echo_string.  It will get recomputed below.  */
 35379   help_echo_string = Qnil;
 35380 
 35381   /* Handle tab-bar highlight on mouse-capable TTY frames.  */
 35382   if (!FRAME_WINDOW_P (f)
 35383       && (y >= FRAME_MENU_BAR_LINES (f)
 35384           && y < FRAME_MENU_BAR_LINES (f) + FRAME_TAB_BAR_LINES (f)))
 35385     {
 35386       int prop_idx;
 35387       bool ignore;
 35388       Lisp_Object caption = tty_get_tab_bar_item (f, x, &prop_idx, &ignore);
 35389 
 35390       if (!NILP (caption))
 35391         {
 35392           help_echo_object = help_echo_window = Qnil;
 35393           help_echo_pos = -1;
 35394           help_echo_string = AREF (f->tab_bar_items,
 35395                                    prop_idx * TAB_BAR_ITEM_NSLOTS
 35396                                    + TAB_BAR_ITEM_HELP);
 35397           if (NILP (help_echo_string))
 35398             help_echo_string = caption;
 35399         }
 35400     }
 35401 
 35402 #ifdef HAVE_WINDOW_SYSTEM
 35403   /* If the cursor is on the internal border of FRAME and FRAME's
 35404      internal border is draggable, provide some visual feedback.  */
 35405   if (FRAME_INTERNAL_BORDER_WIDTH (f) > 0
 35406       && !NILP (get_frame_param (f, Qdrag_internal_border)))
 35407     {
 35408       enum internal_border_part part = frame_internal_border_part (f, x, y);
 35409 
 35410       switch (part)
 35411         {
 35412         case INTERNAL_BORDER_NONE:
 35413           if (cursor != FRAME_OUTPUT_DATA (f)->nontext_cursor)
 35414             /* Reset cursor.  */
 35415             cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35416           break;
 35417         case INTERNAL_BORDER_LEFT_EDGE:
 35418           cursor = FRAME_OUTPUT_DATA (f)->left_edge_cursor;
 35419           break;
 35420         case INTERNAL_BORDER_TOP_LEFT_CORNER:
 35421           cursor = FRAME_OUTPUT_DATA (f)->top_left_corner_cursor;
 35422           break;
 35423         case INTERNAL_BORDER_TOP_EDGE:
 35424           cursor = FRAME_OUTPUT_DATA (f)->top_edge_cursor;
 35425           break;
 35426         case INTERNAL_BORDER_TOP_RIGHT_CORNER:
 35427           cursor = FRAME_OUTPUT_DATA (f)->top_right_corner_cursor;
 35428           break;
 35429         case INTERNAL_BORDER_RIGHT_EDGE:
 35430           cursor = FRAME_OUTPUT_DATA (f)->right_edge_cursor;
 35431           break;
 35432         case INTERNAL_BORDER_BOTTOM_RIGHT_CORNER:
 35433           cursor = FRAME_OUTPUT_DATA (f)->bottom_right_corner_cursor;
 35434           break;
 35435         case INTERNAL_BORDER_BOTTOM_EDGE:
 35436           cursor = FRAME_OUTPUT_DATA (f)->bottom_edge_cursor;
 35437           break;
 35438         case INTERNAL_BORDER_BOTTOM_LEFT_CORNER:
 35439           cursor = FRAME_OUTPUT_DATA (f)->bottom_left_corner_cursor;
 35440           break;
 35441         default:
 35442           /* This should not happen.  */
 35443           if (cursor != FRAME_OUTPUT_DATA (f)->nontext_cursor)
 35444             cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35445         }
 35446 
 35447       if (cursor != FRAME_OUTPUT_DATA (f)->nontext_cursor)
 35448         {
 35449           /* Do we really want a help echo here?  */
 35450           help_echo_string = build_string ("drag-mouse-1: resize frame");
 35451           goto set_cursor;
 35452         }
 35453     }
 35454 #endif /* HAVE_WINDOW_SYSTEM */
 35455 
 35456   /* Not on a window -> return.  */
 35457   if (!WINDOWP (window))
 35458     return;
 35459 
 35460   /* Convert to window-relative pixel coordinates.  */
 35461   w = XWINDOW (window);
 35462   frame_to_window_pixel_xy (w, &x, &y);
 35463 
 35464 #if defined (HAVE_WINDOW_SYSTEM)
 35465   /* Handle tab-bar window differently since it doesn't display a
 35466      buffer.  */
 35467   if (EQ (window, f->tab_bar_window))
 35468     {
 35469       note_tab_bar_highlight (f, x, y);
 35470       if (tab_bar__dragging_in_progress)
 35471         {
 35472           cursor = FRAME_OUTPUT_DATA (f)->hand_cursor;
 35473           goto set_cursor;
 35474         }
 35475       else
 35476         return;
 35477     }
 35478   else
 35479     {
 35480       /* The mouse might have pressed into the tab bar, but might
 35481          also have been released outside the tab bar, so
 35482          f->last_tab_bar_item must be reset, in order to make sure the
 35483          item can be still highlighted again in the future.  */
 35484       f->last_tab_bar_item = -1;
 35485     }
 35486 #endif
 35487 
 35488 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (HAVE_EXT_TOOL_BAR)
 35489   /* Handle tool-bar window differently since it doesn't display a
 35490      buffer.  */
 35491   if (EQ (window, f->tool_bar_window))
 35492     {
 35493       note_tool_bar_highlight (f, x, y);
 35494       return;
 35495     }
 35496 #endif
 35497 
 35498   /* Mouse is on the mode, header line or margin?  */
 35499   if (part == ON_MODE_LINE || part == ON_HEADER_LINE || part == ON_TAB_LINE
 35500       || part == ON_LEFT_MARGIN || part == ON_RIGHT_MARGIN)
 35501     {
 35502       note_mode_line_or_margin_highlight (window, x, y, part);
 35503 
 35504 #ifdef HAVE_WINDOW_SYSTEM
 35505       if (part == ON_LEFT_MARGIN || part == ON_RIGHT_MARGIN)
 35506         {
 35507           cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35508           /* Show non-text cursor (Bug#16647).  */
 35509           goto set_cursor;
 35510         }
 35511       else
 35512 #endif
 35513         return;
 35514     }
 35515 
 35516 #ifdef HAVE_WINDOW_SYSTEM
 35517   if (part == ON_VERTICAL_BORDER)
 35518     {
 35519       cursor = FRAME_OUTPUT_DATA (f)->horizontal_drag_cursor;
 35520       help_echo_string = build_string ("drag-mouse-1: resize");
 35521       goto set_cursor;
 35522     }
 35523   else if (part == ON_RIGHT_DIVIDER)
 35524     {
 35525       cursor = FRAME_OUTPUT_DATA (f)->horizontal_drag_cursor;
 35526       help_echo_string = build_string ("drag-mouse-1: resize");
 35527       goto set_cursor;
 35528     }
 35529   else if (part == ON_BOTTOM_DIVIDER)
 35530     if (! WINDOW_BOTTOMMOST_P (w)
 35531         || minibuf_level
 35532         || NILP (Vresize_mini_windows))
 35533       {
 35534         cursor = FRAME_OUTPUT_DATA (f)->vertical_drag_cursor;
 35535         help_echo_string = build_string ("drag-mouse-1: resize");
 35536         goto set_cursor;
 35537       }
 35538     else
 35539       cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35540   else if (part == ON_LEFT_FRINGE || part == ON_RIGHT_FRINGE
 35541            || part == ON_VERTICAL_SCROLL_BAR
 35542            || part == ON_HORIZONTAL_SCROLL_BAR)
 35543     cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35544   else
 35545     cursor = FRAME_OUTPUT_DATA (f)->text_cursor;
 35546 #endif
 35547 
 35548   /* Are we in a window whose display is up to date?
 35549      And verify the buffer's text has not changed.  */
 35550   b = XBUFFER (w->contents);
 35551   if (part == ON_TEXT && w->window_end_valid && !window_outdated (w))
 35552     {
 35553       int hpos, vpos, dx, dy, area = LAST_AREA;
 35554       ptrdiff_t pos;
 35555       struct glyph *glyph;
 35556       Lisp_Object object;
 35557       Lisp_Object mouse_face = Qnil, position;
 35558       Lisp_Object *overlay_vec = NULL;
 35559       ptrdiff_t i, noverlays;
 35560       struct buffer *obuf;
 35561       ptrdiff_t obegv, ozv;
 35562       bool same_region;
 35563 
 35564       /* Find the glyph under X/Y.  */
 35565       glyph = x_y_to_hpos_vpos (w, x, y, &hpos, &vpos, &dx, &dy, &area);
 35566 
 35567 #ifdef HAVE_WINDOW_SYSTEM
 35568       /* Look for :pointer property on image.  */
 35569       if (glyph != NULL && glyph->type == IMAGE_GLYPH)
 35570         {
 35571           struct image *img = IMAGE_OPT_FROM_ID (f, glyph->u.img_id);
 35572           if (img != NULL && IMAGEP (img->spec))
 35573             {
 35574               Lisp_Object image_map, hotspot;
 35575               if ((image_map = plist_get (XCDR (img->spec), QCmap),
 35576                    !NILP (image_map))
 35577                   && (hotspot = find_hot_spot (image_map,
 35578                                                glyph->slice.img.x + dx,
 35579                                                glyph->slice.img.y + dy),
 35580                       CONSP (hotspot))
 35581                   && (hotspot = XCDR (hotspot), CONSP (hotspot)))
 35582                 {
 35583                   Lisp_Object plist;
 35584 
 35585                   /* Could check XCAR (hotspot) to see if we enter/leave
 35586                      this hot-spot.
 35587                      If so, we could look for mouse-enter, mouse-leave
 35588                      properties in PLIST (and do something...).  */
 35589                   hotspot = XCDR (hotspot);
 35590                   if (CONSP (hotspot)
 35591                       && (plist = XCAR (hotspot), CONSP (plist)))
 35592                     {
 35593                       pointer = plist_get (plist, Qpointer);
 35594                       if (NILP (pointer))
 35595                         pointer = Qhand;
 35596                       help_echo_string = plist_get (plist, Qhelp_echo);
 35597                       if (!NILP (help_echo_string))
 35598                         {
 35599                           help_echo_window = window;
 35600                           help_echo_object = glyph->object;
 35601                           help_echo_pos = glyph->charpos;
 35602                         }
 35603                     }
 35604                 }
 35605               if (NILP (pointer))
 35606                 pointer = plist_get (XCDR (img->spec), QCpointer);
 35607             }
 35608         }
 35609 #endif  /* HAVE_WINDOW_SYSTEM */
 35610 
 35611       /* Clear mouse face if X/Y not over text.  */
 35612       if (glyph == NULL
 35613           || area != TEXT_AREA
 35614           || !MATRIX_ROW_DISPLAYS_TEXT_P (MATRIX_ROW (w->current_matrix, vpos))
 35615           /* Glyph's OBJECT is nil for glyphs inserted by the
 35616              display engine for its internal purposes, like truncation
 35617              and continuation glyphs and blanks beyond the end of
 35618              line's text on text terminals.  If we are over such a
 35619              glyph, we are not over any text.  */
 35620           || NILP (glyph->object)
 35621           /* R2L rows have a stretch glyph at their front, which
 35622              stands for no text, whereas L2R rows have no glyphs at
 35623              all beyond the end of text.  Treat such stretch glyphs
 35624              like we do with NULL glyphs in L2R rows.  */
 35625           || (MATRIX_ROW (w->current_matrix, vpos)->reversed_p
 35626               && glyph == MATRIX_ROW_GLYPH_START (w->current_matrix, vpos)
 35627               && glyph->type == STRETCH_GLYPH
 35628               && glyph->avoid_cursor_p))
 35629         {
 35630           if (clear_mouse_face (hlinfo))
 35631             cursor = No_Cursor;
 35632           if (FRAME_WINDOW_P (f) && NILP (pointer))
 35633             {
 35634 #ifdef HAVE_WINDOW_SYSTEM
 35635               if (area != TEXT_AREA)
 35636                 cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35637               else
 35638                 pointer = Vvoid_text_area_pointer;
 35639 #endif
 35640             }
 35641           goto set_cursor;
 35642         }
 35643 
 35644       pos = glyph->charpos;
 35645       object = glyph->object;
 35646       if (!STRINGP (object) && !BUFFERP (object))
 35647         goto set_cursor;
 35648 
 35649       /* If we get an out-of-range value, return now; avoid an error.  */
 35650       if (BUFFERP (object) && pos > BUF_Z (b))
 35651         goto set_cursor;
 35652 
 35653       /* Make the window's buffer temporarily current for
 35654          overlays_at and compute_char_face.  */
 35655       obuf = current_buffer;
 35656       current_buffer = b;
 35657       obegv = BEGV;
 35658       ozv = ZV;
 35659       BEGV = BEG;
 35660       ZV = Z;
 35661 
 35662       /* Is this char mouse-active or does it have help-echo?  */
 35663       position = make_fixnum (pos);
 35664 
 35665       USE_SAFE_ALLOCA;
 35666 
 35667       if (BUFFERP (object))
 35668         {
 35669           /* Put all the overlays we want in a vector in overlay_vec.  */
 35670           GET_OVERLAYS_AT (pos, overlay_vec, noverlays, NULL);
 35671           /* Sort overlays into increasing priority order.  */
 35672           noverlays = sort_overlays (overlay_vec, noverlays, w);
 35673         }
 35674       else
 35675         noverlays = 0;
 35676 
 35677       if (NILP (Vmouse_highlight))
 35678         {
 35679           clear_mouse_face (hlinfo);
 35680           goto check_help_echo;
 35681         }
 35682 
 35683       same_region = coords_in_mouse_face_p (w, hpos, vpos);
 35684 
 35685       if (same_region)
 35686         cursor = No_Cursor;
 35687 
 35688       /* Check mouse-face highlighting.  */
 35689       if (! same_region
 35690           /* If there exists an overlay with mouse-face overlapping
 35691              the one we are currently highlighting, we have to check
 35692              if we enter the overlapping overlay, and then highlight
 35693              only that.  Skip the check when mouse-face highlighting
 35694              is currently hidden to avoid Bug#30519.  */
 35695           || (!hlinfo->mouse_face_hidden
 35696               && OVERLAYP (hlinfo->mouse_face_overlay)
 35697               /* It's possible the overlay was deleted (Bug#35273).  */
 35698               && OVERLAY_BUFFER (hlinfo->mouse_face_overlay)
 35699               && mouse_face_overlay_overlaps (hlinfo->mouse_face_overlay)))
 35700         {
 35701           /* Find the highest priority overlay with a mouse-face.  */
 35702           Lisp_Object overlay = Qnil;
 35703           for (i = noverlays - 1; i >= 0 && NILP (overlay); --i)
 35704             {
 35705               mouse_face = Foverlay_get (overlay_vec[i], Qmouse_face);
 35706               if (!NILP (mouse_face))
 35707                 overlay = overlay_vec[i];
 35708             }
 35709 
 35710           /* If we're highlighting the same overlay as before, there's
 35711              no need to do that again.  */
 35712           if (!NILP (overlay) && EQ (overlay, hlinfo->mouse_face_overlay))
 35713             goto check_help_echo;
 35714 
 35715           /* Clear the display of the old active region, if any.  */
 35716           if (clear_mouse_face (hlinfo))
 35717             cursor = No_Cursor;
 35718 
 35719           /* Record the overlay, if any, to be highlighted.  */
 35720           hlinfo->mouse_face_overlay = overlay;
 35721 
 35722           /* If no overlay applies, get a text property.  */
 35723           if (NILP (overlay))
 35724             mouse_face = Fget_text_property (position, Qmouse_face, object);
 35725 
 35726           /* Next, compute the bounds of the mouse highlighting and
 35727              display it.  */
 35728           if (!NILP (mouse_face) && STRINGP (object))
 35729             {
 35730               /* The mouse-highlighting comes from a display string
 35731                  with a mouse-face.  */
 35732               Lisp_Object s, e;
 35733               ptrdiff_t ignore;
 35734 
 35735               s = Fprevious_single_property_change
 35736                 (make_fixnum (pos + 1), Qmouse_face, object, Qnil);
 35737               e = Fnext_single_property_change
 35738                 (position, Qmouse_face, object, Qnil);
 35739               if (NILP (s))
 35740                 s = make_fixnum (0);
 35741               if (NILP (e))
 35742                 e = make_fixnum (SCHARS (object));
 35743               mouse_face_from_string_pos (w, hlinfo, object,
 35744                                           XFIXNUM (s), XFIXNUM (e));
 35745               hlinfo->mouse_face_past_end = false;
 35746               hlinfo->mouse_face_window = window;
 35747               hlinfo->mouse_face_face_id
 35748                 = face_at_string_position (w, object, pos, 0, &ignore,
 35749                                            glyph->face_id, true, 0);
 35750               show_mouse_face (hlinfo, DRAW_MOUSE_FACE);
 35751               cursor = No_Cursor;
 35752             }
 35753           else
 35754             {
 35755               /* The mouse-highlighting, if any, comes from an overlay
 35756                  or text property in the buffer.  */
 35757               Lisp_Object buffer UNINIT;
 35758               Lisp_Object disp_string UNINIT;
 35759 
 35760               if (STRINGP (object))
 35761                 {
 35762                   /* If we are on a display string with no mouse-face,
 35763                      check if the text under it has one.  */
 35764                   struct glyph_row *r = MATRIX_ROW (w->current_matrix, vpos);
 35765                   ptrdiff_t start = MATRIX_ROW_START_CHARPOS (r);
 35766                   pos = string_buffer_position (object, start);
 35767                   if (pos > 0)
 35768                     {
 35769                       mouse_face = get_char_property_and_overlay
 35770                         (make_fixnum (pos), Qmouse_face, w->contents, &overlay);
 35771                       buffer = w->contents;
 35772                       disp_string = object;
 35773                     }
 35774                 }
 35775               else
 35776                 {
 35777                   buffer = object;
 35778                   disp_string = Qnil;
 35779                 }
 35780 
 35781               if (!NILP (mouse_face))
 35782                 {
 35783                   Lisp_Object before, after;
 35784                   Lisp_Object before_string, after_string;
 35785                   /* To correctly find the limits of mouse highlight
 35786                      in a bidi-reordered buffer, we must not use the
 35787                      optimization of limiting the search in
 35788                      previous-single-property-change and
 35789                      next-single-property-change, because
 35790                      rows_from_pos_range needs the real start and end
 35791                      positions to DTRT in this case.  That's because
 35792                      the first row visible in a window does not
 35793                      necessarily display the character whose position
 35794                      is the smallest.  */
 35795                   Lisp_Object lim1
 35796                     = NILP (BVAR (XBUFFER (buffer), bidi_display_reordering))
 35797                     ? Fmarker_position (w->start)
 35798                     : Qnil;
 35799                   Lisp_Object lim2
 35800                     = NILP (BVAR (XBUFFER (buffer), bidi_display_reordering))
 35801                     ? make_fixnum (BUF_Z (XBUFFER (buffer))
 35802                                    - w->window_end_pos)
 35803                     : Qnil;
 35804 
 35805                   if (NILP (overlay))
 35806                     {
 35807                       /* Handle the text property case.  */
 35808                       before = Fprevious_single_property_change
 35809                         (make_fixnum (pos + 1), Qmouse_face, buffer, lim1);
 35810                       after = Fnext_single_property_change
 35811                         (make_fixnum (pos), Qmouse_face, buffer, lim2);
 35812                       before_string = after_string = Qnil;
 35813                     }
 35814                   else
 35815                     {
 35816                       /* Handle the overlay case.  */
 35817                       before = Foverlay_start (overlay);
 35818                       after = Foverlay_end (overlay);
 35819                       before_string = Foverlay_get (overlay, Qbefore_string);
 35820                       after_string = Foverlay_get (overlay, Qafter_string);
 35821 
 35822                       if (!STRINGP (before_string)) before_string = Qnil;
 35823                       if (!STRINGP (after_string))  after_string = Qnil;
 35824                     }
 35825 
 35826                   mouse_face_from_buffer_pos (window, hlinfo, pos,
 35827                                               NILP (before)
 35828                                               ? 1
 35829                                               : XFIXNAT (before),
 35830                                               NILP (after)
 35831                                               ? BUF_Z (XBUFFER (buffer))
 35832                                               : XFIXNAT (after),
 35833                                               before_string, after_string,
 35834                                               disp_string);
 35835                   cursor = No_Cursor;
 35836                 }
 35837             }
 35838         }
 35839 
 35840     check_help_echo:
 35841 
 35842       /* Look for a `help-echo' property.  */
 35843       if (NILP (help_echo_string)) {
 35844         Lisp_Object help, overlay;
 35845 
 35846         /* Check overlays first.  */
 35847         help = overlay = Qnil;
 35848         for (i = noverlays - 1; i >= 0 && NILP (help); --i)
 35849           {
 35850             overlay = overlay_vec[i];
 35851             help = Foverlay_get (overlay, Qhelp_echo);
 35852           }
 35853 
 35854         if (!NILP (help))
 35855           {
 35856             help_echo_string = help;
 35857             help_echo_window = window;
 35858             help_echo_object = overlay;
 35859             help_echo_pos = pos;
 35860           }
 35861         else
 35862           {
 35863             Lisp_Object obj = glyph->object;
 35864             ptrdiff_t charpos = glyph->charpos;
 35865 
 35866             /* Try text properties.  */
 35867             if (STRINGP (obj)
 35868                 && charpos >= 0
 35869                 && charpos < SCHARS (obj))
 35870               {
 35871                 help = Fget_text_property (make_fixnum (charpos),
 35872                                            Qhelp_echo, obj);
 35873                 if (NILP (help))
 35874                   {
 35875                     /* If the string itself doesn't specify a help-echo,
 35876                        see if the buffer text ``under'' it does.  */
 35877                     struct glyph_row *r
 35878                       = MATRIX_ROW (w->current_matrix, vpos);
 35879                     ptrdiff_t start = MATRIX_ROW_START_CHARPOS (r);
 35880                     ptrdiff_t p = string_buffer_position (obj, start);
 35881                     if (p > 0)
 35882                       {
 35883                         help = Fget_char_property (make_fixnum (p),
 35884                                                    Qhelp_echo, w->contents);
 35885                         if (!NILP (help))
 35886                           {
 35887                             charpos = p;
 35888                             obj = w->contents;
 35889                           }
 35890                       }
 35891                   }
 35892               }
 35893             else if (BUFFERP (obj)
 35894                      && charpos >= BEGV
 35895                      && charpos < ZV)
 35896               help = Fget_text_property (make_fixnum (charpos), Qhelp_echo,
 35897                                          obj);
 35898 
 35899             if (!NILP (help))
 35900               {
 35901                 help_echo_string = help;
 35902                 help_echo_window = window;
 35903                 help_echo_object = obj;
 35904                 help_echo_pos = charpos;
 35905               }
 35906           }
 35907       }
 35908 
 35909 #ifdef HAVE_WINDOW_SYSTEM
 35910       /* Look for a `pointer' property.  */
 35911       if (FRAME_WINDOW_P (f) && NILP (pointer))
 35912         {
 35913           /* Check overlays first.  */
 35914           for (i = noverlays - 1; i >= 0 && NILP (pointer); --i)
 35915             pointer = Foverlay_get (overlay_vec[i], Qpointer);
 35916 
 35917           if (NILP (pointer))
 35918             {
 35919               Lisp_Object obj = glyph->object;
 35920               ptrdiff_t charpos = glyph->charpos;
 35921 
 35922               /* Try text properties.  */
 35923               if (STRINGP (obj)
 35924                   && charpos >= 0
 35925                   && charpos < SCHARS (obj))
 35926                 {
 35927                   pointer = Fget_text_property (make_fixnum (charpos),
 35928                                                 Qpointer, obj);
 35929                   if (NILP (pointer))
 35930                     {
 35931                       /* If the string itself doesn't specify a pointer,
 35932                          see if the buffer text ``under'' it does.  */
 35933                       struct glyph_row *r
 35934                         = MATRIX_ROW (w->current_matrix, vpos);
 35935                       ptrdiff_t start = MATRIX_ROW_START_CHARPOS (r);
 35936                       ptrdiff_t p = string_buffer_position (obj, start);
 35937                       if (p > 0)
 35938                         pointer = Fget_char_property (make_fixnum (p),
 35939                                                       Qpointer, w->contents);
 35940                     }
 35941                 }
 35942               else if (BUFFERP (obj)
 35943                        && charpos >= BEGV
 35944                        && charpos < ZV)
 35945                 pointer = Fget_text_property (make_fixnum (charpos),
 35946                                               Qpointer, obj);
 35947             }
 35948         }
 35949 #endif  /* HAVE_WINDOW_SYSTEM */
 35950 
 35951       BEGV = obegv;
 35952       ZV = ozv;
 35953       current_buffer = obuf;
 35954       SAFE_FREE ();
 35955     }
 35956 
 35957  set_cursor:
 35958   define_frame_cursor1 (f, cursor, pointer);
 35959 }
 35960 
 35961 
 35962 /* EXPORT for RIF:
 35963    Clear any mouse-face on window W.  This function is part of the
 35964    redisplay interface, and is called from try_window_id and similar
 35965    functions to ensure the mouse-highlight is off.  */
 35966 
 35967 void
 35968 gui_clear_window_mouse_face (struct window *w)
 35969 {
 35970   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
 35971   Lisp_Object window;
 35972 
 35973   block_input ();
 35974   XSETWINDOW (window, w);
 35975   if (EQ (window, hlinfo->mouse_face_window))
 35976     clear_mouse_face (hlinfo);
 35977   unblock_input ();
 35978 }
 35979 
 35980 
 35981 /* EXPORT:
 35982    Just discard the mouse face information for frame F, if any.
 35983    This is used when the size of F is changed.  */
 35984 
 35985 void
 35986 cancel_mouse_face (struct frame *f)
 35987 {
 35988   Lisp_Object window;
 35989   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 35990 
 35991   window = hlinfo->mouse_face_window;
 35992   if (! NILP (window) && XFRAME (XWINDOW (window)->frame) == f)
 35993     reset_mouse_highlight (hlinfo);
 35994 }
 35995 
 35996 
 35997 
 35998 /***********************************************************************
 35999                            Exposure Events
 36000  ***********************************************************************/
 36001 
 36002 #ifdef HAVE_WINDOW_SYSTEM
 36003 
 36004 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
 36005    which intersects rectangle R.  R is in window-relative coordinates.  */
 36006 
 36007 static void
 36008 expose_area (struct window *w, struct glyph_row *row, const Emacs_Rectangle *r,
 36009              enum glyph_row_area area)
 36010 {
 36011   struct glyph *first = row->glyphs[area];
 36012   struct glyph *end = row->glyphs[area] + row->used[area];
 36013   struct glyph *last;
 36014   int first_x, start_x, x;
 36015 
 36016   if (area == TEXT_AREA && row->fill_line_p)
 36017     /* If row extends face to end of line write the whole line.  */
 36018     draw_glyphs (w, row->x, row, area,
 36019                  0, row->used[area],
 36020                  DRAW_NORMAL_TEXT, 0);
 36021   else
 36022     {
 36023       /* Set START_X to the window-relative start position for drawing glyphs of
 36024          AREA.  The first glyph of the text area can be partially visible.
 36025          The first glyphs of other areas cannot.  */
 36026       start_x = window_box_left_offset (w, area);
 36027       x = start_x;
 36028       if (area == TEXT_AREA)
 36029         x += row->x;
 36030 
 36031       /* Find the first glyph that must be redrawn.  */
 36032       while (first < end
 36033              && x + first->pixel_width < r->x)
 36034         {
 36035           x += first->pixel_width;
 36036           ++first;
 36037         }
 36038 
 36039       /* Find the last one.  */
 36040       last = first;
 36041       first_x = x;
 36042       /* Use a signed int intermediate value to avoid catastrophic
 36043          failures due to comparison between signed and unsigned, when
 36044          x is negative (can happen for wide images that are hscrolled).  */
 36045       int r_end = r->x + r->width;
 36046       while (last < end && x < r_end)
 36047         {
 36048           x += last->pixel_width;
 36049           ++last;
 36050         }
 36051 
 36052       /* Repaint.  */
 36053       if (last > first)
 36054         draw_glyphs (w, first_x - start_x, row, area,
 36055                      first - row->glyphs[area], last - row->glyphs[area],
 36056                      DRAW_NORMAL_TEXT, 0);
 36057     }
 36058 }
 36059 
 36060 
 36061 /* Redraw the parts of the glyph row ROW on window W intersecting
 36062    rectangle R.  R is in window-relative coordinates.  Value is
 36063    true if mouse-face was overwritten.  */
 36064 
 36065 static bool
 36066 expose_line (struct window *w, struct glyph_row *row, const Emacs_Rectangle *r)
 36067 {
 36068   eassert (row->enabled_p);
 36069 
 36070   if (row->mode_line_p || w->pseudo_window_p)
 36071     draw_glyphs (w, 0, row, TEXT_AREA,
 36072                  0, row->used[TEXT_AREA],
 36073                  DRAW_NORMAL_TEXT, 0);
 36074   else
 36075     {
 36076       if (row->used[LEFT_MARGIN_AREA])
 36077         expose_area (w, row, r, LEFT_MARGIN_AREA);
 36078       if (row->used[TEXT_AREA])
 36079         expose_area (w, row, r, TEXT_AREA);
 36080       if (row->used[RIGHT_MARGIN_AREA])
 36081         expose_area (w, row, r, RIGHT_MARGIN_AREA);
 36082       draw_row_fringe_bitmaps (w, row);
 36083     }
 36084 
 36085   return row->mouse_face_p;
 36086 }
 36087 
 36088 
 36089 /* Redraw those parts of glyphs rows during expose event handling that
 36090    overlap other rows.  Redrawing of an exposed line writes over parts
 36091    of lines overlapping that exposed line; this function fixes that.
 36092 
 36093    W is the window being exposed.  FIRST_OVERLAPPING_ROW is the first
 36094    row in W's current matrix that is exposed and overlaps other rows.
 36095    LAST_OVERLAPPING_ROW is the last such row.  */
 36096 
 36097 static void
 36098 expose_overlaps (struct window *w,
 36099                  struct glyph_row *first_overlapping_row,
 36100                  struct glyph_row *last_overlapping_row,
 36101                  const Emacs_Rectangle *r)
 36102 {
 36103   struct glyph_row *row;
 36104 
 36105   for (row = first_overlapping_row; row <= last_overlapping_row; ++row)
 36106     if (row->overlapping_p)
 36107       {
 36108         eassert (row->enabled_p && !row->mode_line_p);
 36109 
 36110         row->clip = r;
 36111         if (row->used[LEFT_MARGIN_AREA])
 36112           gui_fix_overlapping_area (w, row, LEFT_MARGIN_AREA, OVERLAPS_BOTH);
 36113 
 36114         if (row->used[TEXT_AREA])
 36115           gui_fix_overlapping_area (w, row, TEXT_AREA, OVERLAPS_BOTH);
 36116 
 36117         if (row->used[RIGHT_MARGIN_AREA])
 36118           gui_fix_overlapping_area (w, row, RIGHT_MARGIN_AREA, OVERLAPS_BOTH);
 36119         row->clip = NULL;
 36120       }
 36121 }
 36122 
 36123 
 36124 /* Return true if W's cursor intersects rectangle R.  */
 36125 
 36126 static bool
 36127 phys_cursor_in_rect_p (struct window *w, const Emacs_Rectangle *r)
 36128 {
 36129   Emacs_Rectangle cr, result;
 36130   struct glyph *cursor_glyph;
 36131   struct glyph_row *row;
 36132 
 36133   if (w->phys_cursor.vpos >= 0
 36134       && w->phys_cursor.vpos < w->current_matrix->nrows
 36135       && (row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos),
 36136           row->enabled_p)
 36137       && row->cursor_in_fringe_p)
 36138     {
 36139       /* Cursor is in the fringe.  */
 36140       cr.x = window_box_right_offset (w,
 36141                                       (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
 36142                                        ? RIGHT_MARGIN_AREA
 36143                                        : TEXT_AREA));
 36144       cr.y = row->y;
 36145       cr.width = WINDOW_RIGHT_FRINGE_WIDTH (w);
 36146       cr.height = row->height;
 36147       return gui_intersect_rectangles (&cr, r, &result);
 36148     }
 36149 
 36150   cursor_glyph = get_phys_cursor_glyph (w);
 36151   if (cursor_glyph)
 36152     {
 36153       /* r is relative to W's box, but w->phys_cursor.x is relative
 36154          to left edge of W's TEXT area.  Adjust it.  */
 36155       cr.x = window_box_left_offset (w, TEXT_AREA) + w->phys_cursor.x;
 36156       cr.y = w->phys_cursor.y;
 36157       cr.width = cursor_glyph->pixel_width;
 36158       cr.height = w->phys_cursor_height;
 36159       /* ++KFS: W32 version used W32-specific IntersectRect here, but
 36160          I assume the effect is the same -- and this is portable.  */
 36161       return gui_intersect_rectangles (&cr, r, &result);
 36162     }
 36163   /* If we don't understand the format, pretend we're not in the hot-spot.  */
 36164   return false;
 36165 }
 36166 
 36167 
 36168 /* EXPORT:
 36169    Draw a vertical window border to the right of window W if W doesn't
 36170    have vertical scroll bars.  */
 36171 
 36172 void
 36173 gui_draw_vertical_border (struct window *w)
 36174 {
 36175   struct frame *f = XFRAME (WINDOW_FRAME (w));
 36176 
 36177   /* We could do better, if we knew what type of scroll-bar the adjacent
 36178      windows (on either side) have...  But we don't :-(
 36179      However, I think this works ok.  ++KFS 2003-04-25 */
 36180 
 36181   /* Redraw borders between horizontally adjacent windows.  Don't
 36182      do it for frames with vertical scroll bars because either the
 36183      right scroll bar of a window, or the left scroll bar of its
 36184      neighbor will suffice as a border.  */
 36185   if (FRAME_HAS_VERTICAL_SCROLL_BARS (f) || FRAME_RIGHT_DIVIDER_WIDTH (f))
 36186     return;
 36187 
 36188   /* Note: It is necessary to redraw both the left and the right
 36189      borders, for when only this single window W is being
 36190      redisplayed.  */
 36191   if (!WINDOW_RIGHTMOST_P (w)
 36192       && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
 36193     {
 36194       int x0, x1, y0, y1;
 36195 
 36196       window_box_edges (w, &x0, &y0, &x1, &y1);
 36197       y1 -= 1;
 36198 
 36199       if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
 36200         x1 -= 1;
 36201 
 36202       FRAME_RIF (f)->draw_vertical_window_border (w, x1, y0, y1);
 36203     }
 36204 
 36205   if (!WINDOW_LEFTMOST_P (w)
 36206       && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
 36207     {
 36208       int x0, x1, y0, y1;
 36209 
 36210       window_box_edges (w, &x0, &y0, &x1, &y1);
 36211       y1 -= 1;
 36212 
 36213       if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
 36214         x0 -= 1;
 36215 
 36216       FRAME_RIF (f)->draw_vertical_window_border (w, x0, y0, y1);
 36217     }
 36218 }
 36219 
 36220 
 36221 /* Draw window dividers for window W.  */
 36222 
 36223 void
 36224 gui_draw_right_divider (struct window *w)
 36225 {
 36226   struct frame *f = WINDOW_XFRAME (w);
 36227 
 36228   if (w->mini || w->pseudo_window_p)
 36229     return;
 36230   else if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
 36231     {
 36232       int x0 = WINDOW_RIGHT_EDGE_X (w) - WINDOW_RIGHT_DIVIDER_WIDTH (w);
 36233       int x1 = WINDOW_RIGHT_EDGE_X (w);
 36234       int y0 = WINDOW_TOP_EDGE_Y (w);
 36235       int y1 = WINDOW_BOTTOM_EDGE_Y (w);
 36236 
 36237       /* If W is horizontally combined and has a right sibling, don't
 36238          draw over any bottom divider.  */
 36239       if (WINDOW_BOTTOM_DIVIDER_WIDTH (w)
 36240           && !NILP (w->parent)
 36241           && WINDOW_HORIZONTAL_COMBINATION_P (XWINDOW (w->parent))
 36242           && !NILP (w->next))
 36243         y1 -= WINDOW_BOTTOM_DIVIDER_WIDTH (w);
 36244 
 36245       FRAME_RIF (f)->draw_window_divider (w, x0, x1, y0, y1);
 36246     }
 36247 }
 36248 
 36249 static void
 36250 gui_draw_bottom_divider (struct window *w)
 36251 {
 36252   struct frame *f = XFRAME (WINDOW_FRAME (w));
 36253 
 36254   if (w->mini || w->pseudo_window_p)
 36255     return;
 36256   else if (WINDOW_BOTTOM_DIVIDER_WIDTH (w))
 36257     {
 36258       int x0 = WINDOW_LEFT_EDGE_X (w);
 36259       int x1 = WINDOW_RIGHT_EDGE_X (w);
 36260       int y0 = WINDOW_BOTTOM_EDGE_Y (w) - WINDOW_BOTTOM_DIVIDER_WIDTH (w);
 36261       int y1 = WINDOW_BOTTOM_EDGE_Y (w);
 36262       struct window *p = !NILP (w->parent) ? XWINDOW (w->parent) : NULL;
 36263 
 36264       /* If W is vertically combined and has a sibling below, don't draw
 36265          over any right divider.  */
 36266       if (WINDOW_RIGHT_DIVIDER_WIDTH (w)
 36267           && p
 36268           && ((WINDOW_VERTICAL_COMBINATION_P (p)
 36269                && !NILP (w->next))
 36270               || (WINDOW_HORIZONTAL_COMBINATION_P (p)
 36271                   && NILP (w->next)
 36272                   && !NILP (p->parent)
 36273                   && WINDOW_VERTICAL_COMBINATION_P (XWINDOW (p->parent))
 36274                   && !NILP (XWINDOW (p->parent)->next))))
 36275         x1 -= WINDOW_RIGHT_DIVIDER_WIDTH (w);
 36276 
 36277       FRAME_RIF (f)->draw_window_divider (w, x0, x1, y0, y1);
 36278     }
 36279 }
 36280 
 36281 /* Redraw the part of window W intersection rectangle FR.  Pixel
 36282    coordinates in FR are frame-relative.  Call this function with
 36283    input blocked.  Value is true if the exposure overwrites
 36284    mouse-face.  */
 36285 
 36286 static bool
 36287 expose_window (struct window *w, const Emacs_Rectangle *fr)
 36288 {
 36289   struct frame *f = XFRAME (w->frame);
 36290   Emacs_Rectangle wr, r;
 36291   bool mouse_face_overwritten_p = false;
 36292 
 36293   /* If window is not yet fully initialized, do nothing.  This can
 36294      happen when toolkit scroll bars are used and a window is split.
 36295      Reconfiguring the scroll bar will generate an expose for a newly
 36296      created window.  */
 36297   if (w->current_matrix == NULL)
 36298     return false;
 36299 
 36300   /* When we're currently updating the window, display and current
 36301      matrix usually don't agree.  Arrange for a thorough display
 36302      later.  */
 36303   if (w->must_be_updated_p)
 36304     {
 36305       SET_FRAME_GARBAGED (f);
 36306       return false;
 36307     }
 36308 
 36309   /* Frame-relative pixel rectangle of W.  */
 36310   wr.x = WINDOW_LEFT_EDGE_X (w);
 36311   wr.y = WINDOW_TOP_EDGE_Y (w);
 36312   wr.width = WINDOW_PIXEL_WIDTH (w);
 36313   wr.height = WINDOW_PIXEL_HEIGHT (w);
 36314 
 36315   if (gui_intersect_rectangles (fr, &wr, &r))
 36316     {
 36317       int yb = window_text_bottom_y (w);
 36318       struct glyph_row *row;
 36319       struct glyph_row *first_overlapping_row, *last_overlapping_row;
 36320 
 36321       redisplay_trace ("expose_window (%d, %d, %u, %u)\n",
 36322                        r.x, r.y, r.width, r.height);
 36323 
 36324       /* Convert to window coordinates.  */
 36325       r.x -= WINDOW_LEFT_EDGE_X (w);
 36326       r.y -= WINDOW_TOP_EDGE_Y (w);
 36327 
 36328       /* Turn off the cursor.  */
 36329       bool cursor_cleared_p = (!w->pseudo_window_p
 36330                                && phys_cursor_in_rect_p (w, &r));
 36331       if (cursor_cleared_p)
 36332         gui_clear_cursor (w);
 36333 
 36334       /* If the row containing the cursor extends face to end of line,
 36335          then expose_area might overwrite the cursor outside the
 36336          rectangle and thus notice_overwritten_cursor might clear
 36337          w->phys_cursor_on_p.  We remember the original value and
 36338          check later if it is changed.  */
 36339       bool phys_cursor_on_p = w->phys_cursor_on_p;
 36340 
 36341       /* Use a signed int intermediate value to avoid catastrophic
 36342          failures due to comparison between signed and unsigned, when
 36343          y0 or y1 is negative (can happen for tall images).  */
 36344       int r_bottom = r.y + r.height;
 36345 
 36346       /* We must temporarily switch to the window's buffer, in case
 36347          the fringe face has been remapped in that buffer's
 36348          face-remapping-alist, so that draw_row_fringe_bitmaps,
 36349          called from expose_line, will use the right face.  */
 36350       bool buffer_changed = false;
 36351       struct buffer *oldbuf = current_buffer;
 36352       if (!w->pseudo_window_p)
 36353         {
 36354           set_buffer_internal_1 (XBUFFER (w->contents));
 36355           buffer_changed = true;
 36356         }
 36357 
 36358       /* Update lines intersecting rectangle R.  */
 36359       first_overlapping_row = last_overlapping_row = NULL;
 36360       for (row = w->current_matrix->rows;
 36361            row->enabled_p;
 36362            ++row)
 36363         {
 36364           int y0 = row->y;
 36365           int y1 = MATRIX_ROW_BOTTOM_Y (row);
 36366 
 36367           if ((y0 >= r.y && y0 < r_bottom)
 36368               || (y1 > r.y && y1 < r_bottom)
 36369               || (r.y >= y0 && r.y < y1)
 36370               || (r_bottom > y0 && r_bottom < y1))
 36371             {
 36372               /* A header line may be overlapping, but there is no need
 36373                  to fix overlapping areas for them.  KFS 2005-02-12 */
 36374               if (row->overlapping_p && !row->mode_line_p)
 36375                 {
 36376                   if (first_overlapping_row == NULL)
 36377                     first_overlapping_row = row;
 36378                   last_overlapping_row = row;
 36379                 }
 36380 
 36381               row->clip = fr;
 36382               if (expose_line (w, row, &r))
 36383                 mouse_face_overwritten_p = true;
 36384               row->clip = NULL;
 36385             }
 36386           else if (row->overlapping_p)
 36387             {
 36388               /* We must redraw a row overlapping the exposed area.  */
 36389               if (y0 < r.y
 36390                   ? y0 + row->phys_height > r.y
 36391                   : y0 + row->ascent - row->phys_ascent < r.y +r.height)
 36392                 {
 36393                   if (first_overlapping_row == NULL)
 36394                     first_overlapping_row = row;
 36395                   last_overlapping_row = row;
 36396                 }
 36397             }
 36398 
 36399           if (y1 >= yb)
 36400             break;
 36401         }
 36402 
 36403       if (buffer_changed)
 36404         set_buffer_internal_1 (oldbuf);
 36405 
 36406       /* Display the mode line if there is one.  */
 36407       if (window_wants_mode_line (w)
 36408           && (row = MATRIX_MODE_LINE_ROW (w->current_matrix),
 36409               row->enabled_p)
 36410           && row->y < r_bottom)
 36411         {
 36412           if (expose_line (w, row, &r))
 36413             mouse_face_overwritten_p = true;
 36414         }
 36415 
 36416       if (!w->pseudo_window_p)
 36417         {
 36418           /* Fix the display of overlapping rows.  */
 36419           if (first_overlapping_row)
 36420             expose_overlaps (w, first_overlapping_row, last_overlapping_row,
 36421                              fr);
 36422 
 36423           /* Draw border between windows.  */
 36424           if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
 36425             gui_draw_right_divider (w);
 36426           else
 36427             gui_draw_vertical_border (w);
 36428 
 36429           if (WINDOW_BOTTOM_DIVIDER_WIDTH (w))
 36430             gui_draw_bottom_divider (w);
 36431 
 36432           /* Turn the cursor on again.  */
 36433           if (cursor_cleared_p
 36434               || (phys_cursor_on_p && !w->phys_cursor_on_p))
 36435             update_window_cursor (w, true);
 36436         }
 36437     }
 36438 
 36439   return mouse_face_overwritten_p;
 36440 }
 36441 
 36442 
 36443 
 36444 /* Redraw (parts) of all windows in the window tree rooted at W that
 36445    intersect R.  R contains frame pixel coordinates.  Value is
 36446    true if the exposure overwrites mouse-face.  */
 36447 
 36448 static bool
 36449 expose_window_tree (struct window *w, const Emacs_Rectangle *r)
 36450 {
 36451   struct frame *f = XFRAME (w->frame);
 36452   bool mouse_face_overwritten_p = false;
 36453 
 36454   while (w && !FRAME_GARBAGED_P (f))
 36455     {
 36456       mouse_face_overwritten_p
 36457         |= (WINDOWP (w->contents)
 36458             ? expose_window_tree (XWINDOW (w->contents), r)
 36459             : expose_window (w, r));
 36460 
 36461       w = NILP (w->next) ? NULL : XWINDOW (w->next);
 36462     }
 36463 
 36464   return mouse_face_overwritten_p;
 36465 }
 36466 
 36467 
 36468 /* EXPORT:
 36469    Redisplay an exposed area of frame F.  X and Y are the upper-left
 36470    corner of the exposed rectangle.  W and H are width and height of
 36471    the exposed area.  All are pixel values.  W or H zero means redraw
 36472    the entire frame.  */
 36473 
 36474 void
 36475 expose_frame (struct frame *f, int x, int y, int w, int h)
 36476 {
 36477   Emacs_Rectangle r;
 36478   bool mouse_face_overwritten_p = false;
 36479 
 36480   if (FRAME_GARBAGED_P (f))
 36481     {
 36482       redisplay_trace ("expose_frame garbaged\n");
 36483       return;
 36484     }
 36485 
 36486   /* If basic faces haven't been realized yet, there is no point in
 36487      trying to redraw anything.  This can happen when we get an expose
 36488      event while Emacs is starting, e.g. by moving another window.  */
 36489   if (FRAME_FACE_CACHE (f) == NULL
 36490       || FRAME_FACE_CACHE (f)->used < BASIC_FACE_ID_SENTINEL)
 36491     {
 36492       redisplay_trace ("expose_frame no faces\n");
 36493       return;
 36494     }
 36495 
 36496   if (w == 0 || h == 0)
 36497     {
 36498       r.x = r.y = 0;
 36499       r.width = FRAME_TEXT_WIDTH (f);
 36500       r.height = FRAME_TEXT_HEIGHT (f);
 36501     }
 36502   else
 36503     {
 36504       r.x = x;
 36505       r.y = y;
 36506       r.width = w;
 36507       r.height = h;
 36508     }
 36509 
 36510   redisplay_trace ("expose_frame (%d, %d, %u, %u)\n",
 36511                    r.x, r.y, r.width, r.height);
 36512   mouse_face_overwritten_p = expose_window_tree (XWINDOW (f->root_window), &r);
 36513 
 36514   if (WINDOWP (f->tab_bar_window))
 36515     mouse_face_overwritten_p
 36516       |= expose_window (XWINDOW (f->tab_bar_window), &r);
 36517 
 36518 #ifndef HAVE_EXT_TOOL_BAR
 36519   if (WINDOWP (f->tool_bar_window))
 36520     mouse_face_overwritten_p
 36521       |= expose_window (XWINDOW (f->tool_bar_window), &r);
 36522 #endif
 36523 
 36524 #if defined HAVE_WINDOW_SYSTEM && !defined HAVE_EXT_MENU_BAR
 36525   if (WINDOWP (f->menu_bar_window))
 36526     mouse_face_overwritten_p
 36527       |= expose_window (XWINDOW (f->menu_bar_window), &r);
 36528 #endif
 36529 
 36530   /* Some window managers support a focus-follows-mouse style with
 36531      delayed raising of frames.  Imagine a partially obscured frame,
 36532      and moving the mouse into partially obscured mouse-face on that
 36533      frame.  The visible part of the mouse-face will be highlighted,
 36534      then the WM raises the obscured frame.  With at least one WM, KDE
 36535      2.1, Emacs is not getting any event for the raising of the frame
 36536      (even tried with SubstructureRedirectMask), only Expose events.
 36537      These expose events will draw text normally, i.e. not
 36538      highlighted.  Which means we must redo the highlight here.
 36539      Subsume it under ``we love X''.  --gerd 2001-08-15  */
 36540   /* Included in Windows version because Windows most likely does not
 36541      do the right thing if any third party tool offers
 36542      focus-follows-mouse with delayed raise.  --jason 2001-10-12  */
 36543   if (mouse_face_overwritten_p && !FRAME_GARBAGED_P (f))
 36544     {
 36545       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 36546       if (f == hlinfo->mouse_face_mouse_frame)
 36547         {
 36548           int mouse_x = hlinfo->mouse_face_mouse_x;
 36549           int mouse_y = hlinfo->mouse_face_mouse_y;
 36550           clear_mouse_face (hlinfo);
 36551           note_mouse_highlight (f, mouse_x, mouse_y);
 36552         }
 36553     }
 36554 }
 36555 
 36556 
 36557 /* EXPORT:
 36558    Determine the intersection of two rectangles R1 and R2.  Return
 36559    the intersection in *RESULT.  Value is true if RESULT is not
 36560    empty.  */
 36561 
 36562 bool
 36563 gui_intersect_rectangles (const Emacs_Rectangle *r1, const Emacs_Rectangle *r2,
 36564                           Emacs_Rectangle *result)
 36565 {
 36566   const Emacs_Rectangle *left, *right;
 36567   const Emacs_Rectangle *upper, *lower;
 36568   bool intersection_p = false;
 36569 
 36570   /* Rearrange so that R1 is the left-most rectangle.  */
 36571   if (r1->x < r2->x)
 36572     left = r1, right = r2;
 36573   else
 36574     left = r2, right = r1;
 36575 
 36576   /* X0 of the intersection is right.x0, if this is inside R1,
 36577      otherwise there is no intersection.  */
 36578   if (right->x <= left->x + left->width)
 36579     {
 36580       result->x = right->x;
 36581 
 36582       /* The right end of the intersection is the minimum of
 36583          the right ends of left and right.  */
 36584       result->width = (min (left->x + left->width, right->x + right->width)
 36585                        - result->x);
 36586 
 36587       /* Same game for Y.  */
 36588       if (r1->y < r2->y)
 36589         upper = r1, lower = r2;
 36590       else
 36591         upper = r2, lower = r1;
 36592 
 36593       /* The upper end of the intersection is lower.y0, if this is inside
 36594          of upper.  Otherwise, there is no intersection.  */
 36595       if (lower->y <= upper->y + upper->height)
 36596         {
 36597           result->y = lower->y;
 36598 
 36599           /* The lower end of the intersection is the minimum of the lower
 36600              ends of upper and lower.  */
 36601           result->height = (min (lower->y + lower->height,
 36602                                  upper->y + upper->height)
 36603                             - result->y);
 36604           intersection_p = true;
 36605         }
 36606     }
 36607 
 36608   return intersection_p;
 36609 }
 36610 
 36611 /* EXPORT:
 36612    Determine the union of the rectangles A and B.  Return the smallest
 36613    rectangle encompassing both the bounds of A and B in *RESULT.  It
 36614    is safe for all three arguments to point to each other.  */
 36615 
 36616 void
 36617 gui_union_rectangles (const Emacs_Rectangle *a, const Emacs_Rectangle *b,
 36618                       Emacs_Rectangle *result)
 36619 {
 36620   struct gui_box a_box, b_box, result_box;
 36621 
 36622   /* Handle special cases where one of the rectangles is empty.  */
 36623 
 36624   if (!a->width || !a->height)
 36625     {
 36626       *result = *b;
 36627       return;
 36628     }
 36629   else if (!b->width || !b->height)
 36630     {
 36631       *result = *a;
 36632       return;
 36633     }
 36634 
 36635   /* Convert A and B to boxes.  */
 36636   a_box.x1 = a->x;
 36637   a_box.y1 = a->y;
 36638   a_box.x2 = a->x + a->width;
 36639   a_box.y2 = a->y + a->height;
 36640 
 36641   b_box.x1 = b->x;
 36642   b_box.y1 = b->y;
 36643   b_box.x2 = b->x + b->width;
 36644   b_box.y2 = b->y + b->height;
 36645 
 36646   /* Compute the union of the boxes.  */
 36647   result_box.x1 = min (a_box.x1, b_box.x1);
 36648   result_box.y1 = min (a_box.y1, b_box.y1);
 36649   result_box.x2 = max (a_box.x2, b_box.x2);
 36650   result_box.y2 = max (a_box.y2, b_box.y2);
 36651 
 36652   /* Convert result_box to an XRectangle and put the result in
 36653      RESULT.  */
 36654   result->x = result_box.x1;
 36655   result->y = result_box.y1;
 36656   result->width = result_box.x2 - result_box.x1;
 36657   result->height = result_box.y2 - result_box.y1;
 36658 }
 36659 
 36660 #endif /* HAVE_WINDOW_SYSTEM */
 36661 
 36662 
 36663 /***********************************************************************
 36664                             Initialization
 36665  ***********************************************************************/
 36666 
 36667 void
 36668 syms_of_xdisp (void)
 36669 {
 36670   Vwith_echo_area_save_vector = Qnil;
 36671   staticpro (&Vwith_echo_area_save_vector);
 36672 
 36673   Vmessage_stack = Qnil;
 36674   staticpro (&Vmessage_stack);
 36675 
 36676   /* Non-nil means don't actually do any redisplay.  */
 36677   DEFSYM (Qinhibit_redisplay, "inhibit-redisplay");
 36678 
 36679   DEFSYM (Qredisplay_internal_xC_functionx, "redisplay_internal (C function)");
 36680 
 36681   DEFVAR_BOOL ("scroll-minibuffer-conservatively",
 36682                scroll_minibuffer_conservatively,
 36683                doc: /* Non-nil means scroll conservatively in minibuffer windows.
 36684 When the value is nil, scrolling in minibuffer windows obeys the
 36685 settings of `scroll-conservatively'.  */);
 36686   scroll_minibuffer_conservatively = true; /* bug#44070 */
 36687 
 36688   DEFVAR_BOOL ("inhibit-message", inhibit_message,
 36689               doc:  /* Non-nil means calls to `message' are not displayed.
 36690 They are still logged to the *Messages* buffer.
 36691 
 36692 Do NOT set this globally to a non-nil value, as doing that will
 36693 disable messages everywhere, including in I-search and other
 36694 places where they are necessary.  This variable is intended to
 36695 be let-bound around code that needs to disable messages temporarily. */);
 36696   inhibit_message = false;
 36697 
 36698   message_dolog_marker1 = Fmake_marker ();
 36699   staticpro (&message_dolog_marker1);
 36700   message_dolog_marker2 = Fmake_marker ();
 36701   staticpro (&message_dolog_marker2);
 36702   message_dolog_marker3 = Fmake_marker ();
 36703   staticpro (&message_dolog_marker3);
 36704 
 36705   defsubr (&Sset_buffer_redisplay);
 36706 #ifdef GLYPH_DEBUG
 36707   defsubr (&Sdump_frame_glyph_matrix);
 36708   defsubr (&Sdump_glyph_matrix);
 36709   defsubr (&Sdump_glyph_row);
 36710   defsubr (&Sdump_tab_bar_row);
 36711   defsubr (&Sdump_tool_bar_row);
 36712   defsubr (&Strace_redisplay);
 36713   defsubr (&Strace_to_stderr);
 36714 #endif
 36715 #ifdef HAVE_WINDOW_SYSTEM
 36716   defsubr (&Stab_bar_height);
 36717   defsubr (&Stool_bar_height);
 36718   defsubr (&Slookup_image_map);
 36719 #endif
 36720   defsubr (&Sline_pixel_height);
 36721   defsubr (&Sformat_mode_line);
 36722   defsubr (&Sinvisible_p);
 36723   defsubr (&Scurrent_bidi_paragraph_direction);
 36724   defsubr (&Swindow_text_pixel_size);
 36725   defsubr (&Sbuffer_text_pixel_size);
 36726   defsubr (&Smove_point_visually);
 36727   defsubr (&Sbidi_find_overridden_directionality);
 36728   defsubr (&Sdisplay__line_is_continued_p);
 36729   defsubr (&Sget_display_property);
 36730   defsubr (&Slong_line_optimizations_p);
 36731 
 36732   DEFSYM (Qmenu_bar_update_hook, "menu-bar-update-hook");
 36733   DEFSYM (Qoverriding_terminal_local_map, "overriding-terminal-local-map");
 36734   DEFSYM (Qoverriding_local_map, "overriding-local-map");
 36735   DEFSYM (Qwindow_scroll_functions, "window-scroll-functions");
 36736   DEFSYM (Qinhibit_point_motion_hooks, "inhibit-point-motion-hooks");
 36737   DEFSYM (Qeval, "eval");
 36738   DEFSYM (QCdata, ":data");
 36739 
 36740   /* Names of text properties relevant for redisplay.  */
 36741   DEFSYM (Qdisplay, "display");
 36742   DEFSYM (Qspace_width, "space-width");
 36743   DEFSYM (Qraise, "raise");
 36744   DEFSYM (Qslice, "slice");
 36745   DEFSYM (Qspace, "space");
 36746   DEFSYM (Qmargin, "margin");
 36747   DEFSYM (Qpointer, "pointer");
 36748   DEFSYM (Qleft_margin, "left-margin");
 36749   DEFSYM (Qright_margin, "right-margin");
 36750   DEFSYM (Qcenter, "center");
 36751   DEFSYM (Qline_height, "line-height");
 36752   DEFSYM (QCalign_to, ":align-to");
 36753   DEFSYM (QCrelative_width, ":relative-width");
 36754   DEFSYM (QCrelative_height, ":relative-height");
 36755   DEFSYM (QCeval, ":eval");
 36756   DEFSYM (QCpropertize, ":propertize");
 36757   DEFSYM (QCfile, ":file");
 36758   DEFSYM (Qfontified, "fontified");
 36759   DEFSYM (Qfontification_functions, "fontification-functions");
 36760   DEFSYM (Qlong_line_optimizations_in_fontification_functions,
 36761           "long-line-optimizations-in-fontification-functions");
 36762 
 36763   /* Name of the symbol which disables Lisp evaluation in 'display'
 36764      properties.  This is used by enriched.el.  */
 36765   DEFSYM (Qdisable_eval, "disable-eval");
 36766 
 36767   /* Name of the face used to highlight trailing whitespace.  */
 36768   DEFSYM (Qtrailing_whitespace, "trailing-whitespace");
 36769 
 36770   /* Names of the faces used to display line numbers.  */
 36771   DEFSYM (Qline_number, "line-number");
 36772   DEFSYM (Qline_number_current_line, "line-number-current-line");
 36773   DEFSYM (Qline_number_major_tick, "line-number-major-tick");
 36774   DEFSYM (Qline_number_minor_tick, "line-number-minor-tick");
 36775   /* Name of a text property which disables line-number display.  */
 36776   DEFSYM (Qdisplay_line_numbers_disable, "display-line-numbers-disable");
 36777 
 36778   /* Name of the face used to display fill column indicator character.  */
 36779   DEFSYM (Qfill_column_indicator, "fill-column-indicator");
 36780 
 36781   /* Name and number of the face used to highlight escape glyphs.  */
 36782   DEFSYM (Qescape_glyph, "escape-glyph");
 36783 
 36784   /* Name and number of the face used to highlight non-breaking
 36785      spaces/hyphens.  */
 36786   DEFSYM (Qnobreak_space, "nobreak-space");
 36787   DEFSYM (Qnobreak_hyphen, "nobreak-hyphen");
 36788 
 36789   /* The symbol 'image' which is the car of the lists used to represent
 36790      images in Lisp.  Also a tool bar style.  */
 36791   DEFSYM (Qimage, "image");
 36792 
 36793   /* Tool bar styles.  */
 36794   DEFSYM (Qtext, "text");
 36795   DEFSYM (Qboth, "both");
 36796   DEFSYM (Qboth_horiz, "both-horiz");
 36797   DEFSYM (Qtext_image_horiz, "text-image-horiz");
 36798 
 36799   /* The image map types.  */
 36800   DEFSYM (QCmap, ":map");
 36801   DEFSYM (QCpointer, ":pointer");
 36802   DEFSYM (Qrect, "rect");
 36803   DEFSYM (Qcircle, "circle");
 36804   DEFSYM (Qpoly, "poly");
 36805 
 36806   DEFSYM (Qinhibit_menubar_update, "inhibit-menubar-update");
 36807 
 36808   DEFSYM (Qgrow_only, "grow-only");
 36809   DEFSYM (Qinhibit_eval_during_redisplay, "inhibit-eval-during-redisplay");
 36810   DEFSYM (Qposition, "position");
 36811   DEFSYM (Qbuffer_position, "buffer-position");
 36812   DEFSYM (Qobject, "object");
 36813 
 36814   /* Cursor shapes.  */
 36815   DEFSYM (Qbar, "bar");
 36816   DEFSYM (Qhbar, "hbar");
 36817   DEFSYM (Qbox, "box");
 36818   DEFSYM (Qhollow, "hollow");
 36819 
 36820   /* Pointer shapes.  */
 36821   DEFSYM (Qhand, "hand");
 36822   DEFSYM (Qarrow, "arrow");
 36823   /* also Qtext */
 36824 
 36825   DEFSYM (Qdragging, "dragging");
 36826   DEFSYM (Qdropping, "dropping");
 36827   DEFSYM (Qdrag_source, "drag-source");
 36828 
 36829   DEFSYM (Qdrag_with_mode_line, "drag-with-mode-line");
 36830   DEFSYM (Qdrag_with_header_line, "drag-with-header-line");
 36831   DEFSYM (Qdrag_with_tab_line, "drag-with-tab-line");
 36832 
 36833   DEFSYM (Qinhibit_free_realized_faces, "inhibit-free-realized-faces");
 36834 
 36835   list_of_error = list1 (Qerror);
 36836   staticpro (&list_of_error);
 36837 
 36838   /* Values of those variables at last redisplay are stored as
 36839      properties on 'overlay-arrow-position' symbol.  However, if
 36840      Voverlay_arrow_position is a marker, last-arrow-position is its
 36841      numerical position.  */
 36842   DEFSYM (Qlast_arrow_position, "last-arrow-position");
 36843   DEFSYM (Qlast_arrow_string, "last-arrow-string");
 36844 
 36845   /* Alternative overlay-arrow-string and overlay-arrow-bitmap
 36846      properties on a symbol in overlay-arrow-variable-list.  */
 36847   DEFSYM (Qoverlay_arrow_string, "overlay-arrow-string");
 36848   DEFSYM (Qoverlay_arrow_bitmap, "overlay-arrow-bitmap");
 36849 
 36850   echo_buffer[0] = echo_buffer[1] = Qnil;
 36851   staticpro (&echo_buffer[0]);
 36852   staticpro (&echo_buffer[1]);
 36853 
 36854   echo_area_buffer[0] = echo_area_buffer[1] = Qnil;
 36855   staticpro (&echo_area_buffer[0]);
 36856   staticpro (&echo_area_buffer[1]);
 36857 
 36858   DEFVAR_LISP ("messages-buffer-name", Vmessages_buffer_name,
 36859     doc: /* The name of the buffer where messages are logged.
 36860 This is normally \"\*Messages*\", but can be rebound by packages that
 36861 wish to redirect messages to a different buffer.  (If the buffer
 36862 doesn't exist, it will be created and put into
 36863 `messages-buffer-mode'.)  */);
 36864   Vmessages_buffer_name = build_string ("*Messages*");
 36865 
 36866   mode_line_proptrans_alist = Qnil;
 36867   staticpro (&mode_line_proptrans_alist);
 36868   mode_line_string_list = Qnil;
 36869   staticpro (&mode_line_string_list);
 36870   mode_line_string_face = Qnil;
 36871   staticpro (&mode_line_string_face);
 36872   mode_line_string_face_prop = Qnil;
 36873   staticpro (&mode_line_string_face_prop);
 36874   Vmode_line_unwind_vector = Qnil;
 36875   staticpro (&Vmode_line_unwind_vector);
 36876 
 36877   DEFSYM (Qmode_line_default_help_echo, "mode-line-default-help-echo");
 36878 
 36879   help_echo_string = Qnil;
 36880   staticpro (&help_echo_string);
 36881   help_echo_object = Qnil;
 36882   staticpro (&help_echo_object);
 36883   help_echo_window = Qnil;
 36884   staticpro (&help_echo_window);
 36885   previous_help_echo_string = Qnil;
 36886   staticpro (&previous_help_echo_string);
 36887   help_echo_pos = -1;
 36888 
 36889   DEFSYM (Qright_to_left, "right-to-left");
 36890   DEFSYM (Qleft_to_right, "left-to-right");
 36891   defsubr (&Sbidi_resolved_levels);
 36892 
 36893 #ifdef HAVE_WINDOW_SYSTEM
 36894   DEFVAR_BOOL ("x-stretch-cursor", x_stretch_cursor_p,
 36895     doc: /* Non-nil means draw block cursor as wide as the glyph under it.
 36896 For example, if a block cursor is over a tab, it will be drawn as
 36897 wide as that tab on the display.  */);
 36898   x_stretch_cursor_p = 0;
 36899 #endif
 36900 
 36901   DEFVAR_LISP ("show-trailing-whitespace", Vshow_trailing_whitespace,
 36902     doc: /* Non-nil means highlight trailing whitespace.
 36903 The face used for trailing whitespace is `trailing-whitespace'.  */);
 36904   Vshow_trailing_whitespace = Qnil;
 36905 
 36906   DEFVAR_LISP ("mode-line-compact", Vmode_line_compact,
 36907     doc: /* Non-nil means that mode lines should be compact.
 36908 This means that repeating spaces will be replaced with a single space.
 36909 If this variable is `long', only mode lines that are wider than the
 36910 currently selected window are compressed. */);
 36911   Vmode_line_compact = Qnil;
 36912   DEFSYM (Qlong, "long");
 36913 
 36914   DEFVAR_LISP ("nobreak-char-display", Vnobreak_char_display,
 36915     doc: /* Control highlighting of non-ASCII space and hyphen chars.
 36916 If the value is t, Emacs highlights non-ASCII chars which have the
 36917 same appearance as an ASCII space or hyphen, using the `nobreak-space'
 36918 or `nobreak-hyphen' face respectively.
 36919 
 36920 All of the non-ASCII characters in the Unicode horizontal whitespace
 36921 character class, as well as U+00AD (soft hyphen), U+2010 (hyphen), and
 36922 U+2011 (non-breaking hyphen) are affected.
 36923 
 36924 Any other non-nil value means to display these characters as an escape
 36925 glyph followed by an ordinary space or hyphen.
 36926 
 36927 A value of nil means no special handling of these characters.  */);
 36928   Vnobreak_char_display = Qt;
 36929 
 36930   DEFVAR_BOOL ("nobreak-char-ascii-display", nobreak_char_ascii_display,
 36931     doc: /* Control display of non-ASCII space and hyphen chars.
 36932 If the value of this variable is nil, the default, Emacs displays
 36933 non-ASCII chars which have the same appearance as an ASCII space
 36934 or hyphen as themselves, with the `nobreak-space' or `nobreak-hyphen'
 36935 face, respectively.
 36936 
 36937 If the value is t, these characters are displayed as their ASCII
 36938 counterparts: whitespace characters as ASCII space, hyphen characters
 36939 as ASCII hyphen (a.k.a. \"dash\"), using the `nobreak-space' or
 36940 the `nobreak-hyphen' face.
 36941 
 36942 This variable has effect only if `nobreak-char-display' is t;
 36943 otherwise it is ignored.
 36944 
 36945 All of the non-ASCII characters in the Unicode horizontal whitespace
 36946 character class, as well as U+00AD (soft hyphen), U+2010 (hyphen), and
 36947 U+2011 (non-breaking hyphen) are affected.  */);
 36948   nobreak_char_ascii_display = false;
 36949 
 36950   DEFVAR_LISP ("void-text-area-pointer", Vvoid_text_area_pointer,
 36951     doc: /* The pointer shape to show in void text areas.
 36952 A value of nil means to show the text pointer.  Other options are
 36953 `arrow', `text', `hand', `vdrag', `hdrag', `nhdrag', `modeline', and
 36954 `hourglass'.  */);
 36955   Vvoid_text_area_pointer = Qarrow;
 36956 
 36957   DEFVAR_LISP ("inhibit-redisplay", Vinhibit_redisplay,
 36958     doc: /* Non-nil means don't actually do any redisplay.
 36959 This is used for internal purposes.  */);
 36960   Vinhibit_redisplay = Qnil;
 36961 
 36962   DEFVAR_LISP ("global-mode-string", Vglobal_mode_string,
 36963     doc: /* String (or mode line construct) included (normally) in `mode-line-misc-info'.  */);
 36964   Vglobal_mode_string = Qnil;
 36965 
 36966   DEFVAR_LISP ("overlay-arrow-position", Voverlay_arrow_position,
 36967     doc: /* Marker for where to display an arrow on top of the buffer text.
 36968 This must be the beginning of a line in order to work.
 36969 See also `overlay-arrow-string'.  */);
 36970   Voverlay_arrow_position = Qnil;
 36971 
 36972   DEFVAR_LISP ("overlay-arrow-string", Voverlay_arrow_string,
 36973     doc: /* String to display as an arrow in non-window frames.
 36974 See also `overlay-arrow-position'.  */);
 36975   Voverlay_arrow_string = build_pure_c_string ("=>");
 36976 
 36977   DEFVAR_LISP ("overlay-arrow-variable-list", Voverlay_arrow_variable_list,
 36978     doc: /* List of variables (symbols) which hold markers for overlay arrows.
 36979 The symbols on this list are examined during redisplay to determine
 36980 where to display overlay arrows.  */);
 36981   Voverlay_arrow_variable_list
 36982     = list1 (intern_c_string ("overlay-arrow-position"));
 36983 
 36984   DEFVAR_INT ("scroll-step", emacs_scroll_step,
 36985     doc: /* The number of lines to try scrolling a window by when point moves out.
 36986 If that fails to bring point back on frame, point is centered instead.
 36987 If this is zero, point is always centered after it moves off frame.
 36988 If you want scrolling to always be a line at a time, you should set
 36989 `scroll-conservatively' to a large value rather than set this to 1.  */);
 36990 
 36991   DEFVAR_INT ("scroll-conservatively", scroll_conservatively,
 36992     doc: /* Scroll up to this many lines, to bring point back on screen.
 36993 If point moves off-screen, redisplay will scroll by up to
 36994 `scroll-conservatively' lines in order to bring point just barely
 36995 onto the screen again.  If that cannot be done, then redisplay
 36996 recenters point as usual.
 36997 
 36998 If the value is greater than 100, redisplay will never recenter point,
 36999 but will always scroll just enough text to bring point into view, even
 37000 if you move far away.
 37001 
 37002 A value of zero means always recenter point if it moves off screen.  */);
 37003   scroll_conservatively = 0;
 37004 
 37005   DEFVAR_INT ("scroll-margin", scroll_margin,
 37006     doc: /* Number of lines of margin at the top and bottom of a window.
 37007 Trigger automatic scrolling whenever point gets within this many lines
 37008 of the top or bottom of the window (see info node `Auto Scrolling').  */);
 37009   scroll_margin = 0;
 37010 
 37011   DEFVAR_LISP ("maximum-scroll-margin", Vmaximum_scroll_margin,
 37012     doc: /* Maximum effective value of `scroll-margin'.
 37013 Given as a fraction of the current window's lines.  The value should
 37014 be a floating point number between 0.0 and 0.5.  The effective maximum
 37015 is limited to (/ (1- window-lines) 2).  Non-float values for this
 37016 variable are ignored and the default 0.25 is used instead.  */);
 37017   Vmaximum_scroll_margin = make_float (0.25);
 37018 
 37019   DEFVAR_LISP ("display-pixels-per-inch",  Vdisplay_pixels_per_inch,
 37020     doc: /* Pixels per inch value for non-window system displays.
 37021 Value is a number or a cons (WIDTH-DPI . HEIGHT-DPI).  */);
 37022   Vdisplay_pixels_per_inch = make_float (72.0);
 37023 
 37024 #ifdef GLYPH_DEBUG
 37025   DEFVAR_INT ("debug-end-pos", debug_end_pos, doc: /* Don't ask.  */);
 37026 #endif
 37027 
 37028   DEFVAR_LISP ("truncate-partial-width-windows",
 37029                Vtruncate_partial_width_windows,
 37030     doc: /* Non-nil means truncate lines in windows narrower than the frame.
 37031 For an integer value, truncate lines in each window narrower than the
 37032 full frame width, provided the total window width in column units is less
 37033 than that integer; otherwise, respect the value of `truncate-lines'.
 37034 The total width of the window is as returned by `window-total-width', it
 37035 includes the fringes, the continuation and truncation glyphs, the
 37036 display margins (if any), and the scroll bar
 37037 
 37038 For any other non-nil value, truncate lines in all windows that do
 37039 not span the full frame width.
 37040 
 37041 A value of nil means to respect the value of `truncate-lines'.
 37042 
 37043 If `word-wrap' is enabled, you might want to reduce the value of this.
 37044 
 37045 Don't set this to a non-nil value when `visual-line-mode' is
 37046 turned on, as it could produce confusing results.  */);
 37047   Vtruncate_partial_width_windows = make_fixnum (50);
 37048 
 37049   DEFVAR_BOOL("word-wrap-by-category", word_wrap_by_category, doc: /*
 37050     Non-nil means also wrap after characters of a certain category.
 37051 Normally when `word-wrap' is on, Emacs only breaks lines after
 37052 whitespace characters.  When this option is turned on, Emacs also
 37053 breaks lines after characters that have the "|" category (defined in
 37054 characters.el).  This is useful for allowing breaking after CJK
 37055 characters and improves the word-wrapping for CJK text mixed with
 37056 Latin text.
 37057 
 37058 If this variable is set using Customize, Emacs automatically loads
 37059 kinsoku.el.  When kinsoku.el is loaded, Emacs respects kinsoku rules
 37060 when breaking lines.  That means characters with the ">" category
 37061 don't appear at the beginning of a line (e.g., FULLWIDTH COMMA), and
 37062 characters with the "<" category don't appear at the end of a line
 37063 (e.g., LEFT DOUBLE ANGLE BRACKET).  */);
 37064   word_wrap_by_category = false;
 37065 
 37066   DEFVAR_LISP ("line-number-display-limit", Vline_number_display_limit,
 37067     doc: /* Maximum buffer size for which line number should be displayed.
 37068 If the buffer is bigger than this, the line number does not appear
 37069 in the mode line.  A value of nil means no limit.  */);
 37070   Vline_number_display_limit = Qnil;
 37071 
 37072   DEFVAR_INT ("line-number-display-limit-width",
 37073               line_number_display_limit_width,
 37074     doc: /* Maximum line width (in characters) for line number display.
 37075 If the average length of the lines near point is bigger than this, then the
 37076 line number may be omitted from the mode line.  */);
 37077   line_number_display_limit_width = 200;
 37078 
 37079   DEFVAR_BOOL ("highlight-nonselected-windows", highlight_nonselected_windows,
 37080     doc: /* Non-nil means highlight active region even in nonselected windows.
 37081 When nil (the default), the active region is only highlighted when
 37082 the window is selected.  */);
 37083   highlight_nonselected_windows = false;
 37084 
 37085   DEFVAR_BOOL ("multiple-frames", multiple_frames,
 37086     doc: /* Non-nil if more than one frame is visible on this display.
 37087 Minibuffer-only frames don't count, but iconified frames do.
 37088 This variable is not guaranteed to be accurate except while processing
 37089 `frame-title-format' and `icon-title-format'.  */);
 37090 
 37091   DEFVAR_LISP ("frame-title-format", Vframe_title_format,
 37092     doc: /* Template for displaying the title bar of visible frames.
 37093 \(Assuming the window manager supports this feature.)
 37094 
 37095 This variable has the same structure as `mode-line-format', except that
 37096 the %c, %C, and %l constructs are ignored.  It is used only on frames for
 37097 which no explicit name has been set (see `modify-frame-parameters').  */);
 37098 
 37099   DEFVAR_LISP ("icon-title-format", Vicon_title_format,
 37100     doc: /* Template for displaying the title bar of an iconified frame.
 37101 \(Assuming the window manager supports this feature.)
 37102 If the value is a string, it should have the same structure
 37103 as `mode-line-format' (which see), and is used only on frames
 37104 for which no explicit name has been set \(see `modify-frame-parameters').
 37105 If the value is t, that means use `frame-title-format' for
 37106 iconified frames.  */);
 37107   /* Do not nest calls to pure_list.  This works around a bug in
 37108      Oracle Developer Studio 12.6.  */
 37109   Lisp_Object icon_title_name_format
 37110     = pure_list (empty_unibyte_string,
 37111                  build_pure_c_string ("%b - GNU Emacs at "),
 37112                  intern_c_string ("system-name"));
 37113   Vicon_title_format
 37114     = Vframe_title_format
 37115     = pure_list (intern_c_string ("multiple-frames"),
 37116                  build_pure_c_string ("%b"),
 37117                  icon_title_name_format);
 37118 
 37119   DEFVAR_LISP ("message-log-max", Vmessage_log_max,
 37120     doc: /* Maximum number of lines to keep in the message log buffer.
 37121 If nil, disable message logging.  If t, log messages but don't truncate
 37122 the buffer when it becomes large.  */);
 37123   Vmessage_log_max = make_fixnum (1000);
 37124 
 37125   DEFVAR_LISP ("window-scroll-functions", Vwindow_scroll_functions,
 37126     doc: /* List of functions to call before redisplaying a window with scrolling.
 37127 Each function is called with two arguments, the window and its new
 37128 display-start position.
 37129 These functions are called whenever the `window-start' marker is modified,
 37130 either to point into another buffer (e.g. via `set-window-buffer') or another
 37131 place in the same buffer.
 37132 When each function is called, the `window-start' marker of its window
 37133 argument has been already set to the new value, and the buffer which that
 37134 window will display is set to be the current buffer.
 37135 Note that the value of `window-end' is not valid when these functions are
 37136 called.
 37137 
 37138 Warning: Do not use this feature to alter the way the window
 37139 is scrolled.  It is not designed for that, and such use probably won't
 37140 work.  */);
 37141   Vwindow_scroll_functions = Qnil;
 37142 
 37143   DEFVAR_LISP ("mouse-autoselect-window", Vmouse_autoselect_window,
 37144      doc: /* Non-nil means autoselect window with mouse pointer.
 37145 If nil, do not autoselect windows.
 37146 A positive number means delay autoselection by that many seconds: a
 37147 window is autoselected only after the mouse has remained in that
 37148 window for the duration of the delay.
 37149 A negative number has a similar effect, but causes windows to be
 37150 autoselected only after the mouse has stopped moving.  (Because of
 37151 the way Emacs compares mouse events, you will occasionally wait twice
 37152 that time before the window gets selected.)
 37153 Any other value means to autoselect window instantaneously when the
 37154 mouse pointer enters it.
 37155 
 37156 Autoselection selects the minibuffer only if it is active, and never
 37157 unselects the minibuffer if it is active.
 37158 
 37159 If you want to use the mouse to autoselect a window on another frame,
 37160 make sure that (1) your window manager has focus follow the mouse and
 37161 (2) the value of the option `focus-follows-mouse' matches the policy
 37162 of your window manager.  */);
 37163   Vmouse_autoselect_window = Qnil;
 37164 
 37165   DEFVAR_LISP ("auto-resize-tab-bars", Vauto_resize_tab_bars,
 37166     doc: /* Non-nil means automatically resize tab-bars.
 37167 This dynamically changes the tab-bar's height to the minimum height
 37168 that is needed to make all tab-bar items visible.
 37169 If value is `grow-only', the tab-bar's height is only increased
 37170 automatically; to decrease the tab-bar height, use \\[recenter],
 37171 after setting `recenter-redisplay' to the value of t.  */);
 37172   Vauto_resize_tab_bars = Qt;
 37173 
 37174   DEFVAR_BOOL ("auto-raise-tab-bar-buttons", auto_raise_tab_bar_buttons_p,
 37175     doc: /* Non-nil means raise tab-bar buttons when the mouse moves over them.  */);
 37176   auto_raise_tab_bar_buttons_p = true;
 37177 
 37178   DEFVAR_LISP ("auto-resize-tool-bars", Vauto_resize_tool_bars,
 37179     doc: /* Non-nil means automatically resize tool-bars.
 37180 This dynamically changes the tool-bar's height to the minimum height
 37181 that is needed to make all tool-bar items visible.
 37182 If value is `grow-only', the tool-bar's height is only increased
 37183 automatically; to decrease the tool-bar height, use \\[recenter],
 37184 after setting `recenter-redisplay' to the value of t.  */);
 37185   Vauto_resize_tool_bars = Qt;
 37186 
 37187   DEFVAR_BOOL ("auto-raise-tool-bar-buttons", auto_raise_tool_bar_buttons_p,
 37188     doc: /* Non-nil means raise tool-bar buttons when the mouse moves over them.  */);
 37189   auto_raise_tool_bar_buttons_p = true;
 37190 
 37191   DEFVAR_LISP ("make-cursor-line-fully-visible", Vmake_cursor_line_fully_visible,
 37192     doc: /* Whether to scroll the window if the cursor line is not fully visible.
 37193 If the value is non-nil, Emacs scrolls or recenters the window to make
 37194 the cursor line fully visible.  The value could also be a function, which
 37195 is called with a single argument, the window to be scrolled, and should
 37196 return non-nil if the partially-visible cursor requires scrolling the
 37197 window, nil if it's okay to leave the cursor partially-visible.  */);
 37198   Vmake_cursor_line_fully_visible = Qt;
 37199   DEFSYM (Qmake_cursor_line_fully_visible, "make-cursor-line-fully-visible");
 37200 
 37201   DEFVAR_BOOL ("make-window-start-visible", make_window_start_visible,
 37202     doc: /* Whether to ensure `window-start' position is never invisible.  */);
 37203   make_window_start_visible = false;
 37204   DEFSYM (Qmake_window_start_visible, "make-window-start-visible");
 37205   Fmake_variable_buffer_local (Qmake_window_start_visible);
 37206 
 37207   DEFSYM (Qclose_tab, "close-tab");
 37208   DEFVAR_LISP ("tab-bar-border", Vtab_bar_border,
 37209     doc: /* Border below tab-bar in pixels.
 37210 If an integer, use it as the height of the border.
 37211 If it is one of `internal-border-width' or `border-width', use the
 37212 value of the corresponding frame parameter.
 37213 Otherwise, no border is added below the tab-bar.  */);
 37214   Vtab_bar_border = Qinternal_border_width;
 37215 
 37216   DEFVAR_LISP ("tab-bar-button-margin", Vtab_bar_button_margin,
 37217     doc: /* Margin around tab-bar buttons in pixels.
 37218 If an integer, use that for both horizontal and vertical margins.
 37219 Otherwise, value should be a pair of integers `(HORZ . VERT)' with
 37220 HORZ specifying the horizontal margin, and VERT specifying the
 37221 vertical margin.  */);
 37222   Vtab_bar_button_margin = make_fixnum (DEFAULT_TAB_BAR_BUTTON_MARGIN);
 37223 
 37224   DEFVAR_INT ("tab-bar-button-relief", tab_bar_button_relief,
 37225     doc: /* Relief thickness of tab-bar buttons.  */);
 37226   tab_bar_button_relief = DEFAULT_TAB_BAR_BUTTON_RELIEF;
 37227 
 37228   DEFVAR_LISP ("tool-bar-border", Vtool_bar_border,
 37229     doc: /* Border below tool-bar in pixels.
 37230 If an integer, use it as the height of the border.
 37231 If it is one of `internal-border-width' or `border-width', use the
 37232 value of the corresponding frame parameter.
 37233 Otherwise, no border is added below the tool-bar.  */);
 37234   Vtool_bar_border = Qinternal_border_width;
 37235 
 37236   DEFVAR_LISP ("tool-bar-button-margin", Vtool_bar_button_margin,
 37237     doc: /* Margin around tool-bar buttons in pixels.
 37238 If an integer, use that for both horizontal and vertical margins.
 37239 Otherwise, value should be a pair of integers `(HORZ . VERT)' with
 37240 HORZ specifying the horizontal margin, and VERT specifying the
 37241 vertical margin.  */);
 37242   Vtool_bar_button_margin = make_fixnum (DEFAULT_TOOL_BAR_BUTTON_MARGIN);
 37243 
 37244   DEFVAR_INT ("tool-bar-button-relief", tool_bar_button_relief,
 37245     doc: /* Relief thickness of tool-bar buttons.  */);
 37246   tool_bar_button_relief = DEFAULT_TOOL_BAR_BUTTON_RELIEF;
 37247 
 37248   DEFVAR_LISP ("tool-bar-style", Vtool_bar_style,
 37249     doc: /* Tool bar style to use.
 37250 It can be one of
 37251  image            - show images only
 37252  text             - show text only
 37253  both             - show both, text below image
 37254  both-horiz       - show text to the right of the image
 37255  text-image-horiz - show text to the left of the image
 37256  any other        - use system default or image if no system default.
 37257 
 37258 This variable only affects the GTK+ toolkit version of Emacs.  */);
 37259   Vtool_bar_style = Qnil;
 37260 
 37261   DEFVAR_INT ("tool-bar-max-label-size", tool_bar_max_label_size,
 37262     doc: /* Maximum number of characters a label can have to be shown.
 37263 The tool bar style must also show labels for this to have any effect, see
 37264 `tool-bar-style'.  */);
 37265   tool_bar_max_label_size = DEFAULT_TOOL_BAR_LABEL_SIZE;
 37266 
 37267   DEFVAR_LISP ("fontification-functions", Vfontification_functions,
 37268     doc: /* List of functions to call to fontify regions of text.
 37269 Each function is called with one argument POS.  Functions must
 37270 fontify a region starting at POS in the current buffer, and give
 37271 fontified regions the property `fontified' with a non-nil value.
 37272 
 37273 Note that, when `long-line-optimizations-p' is non-nil in the buffer,
 37274 these functions are called as if they were in a `with-restriction' form,
 37275 with a `long-line-optimizations-in-fontification-functions' label and
 37276 with the buffer narrowed to a portion around POS whose size is
 37277 specified by `long-line-optimizations-region-size'.  */);
 37278   Vfontification_functions = Qnil;
 37279   Fmake_variable_buffer_local (Qfontification_functions);
 37280 
 37281   DEFVAR_BOOL ("unibyte-display-via-language-environment",
 37282                unibyte_display_via_language_environment,
 37283     doc: /* Non-nil means display unibyte text according to language environment.
 37284 Specifically, this means that raw bytes in the range 160-255 decimal
 37285 are displayed by converting them to the equivalent multibyte characters
 37286 according to the current language environment.  As a result, they are
 37287 displayed according to the current fontset.
 37288 
 37289 Note that this variable affects only how these bytes are displayed,
 37290 but does not change the fact they are interpreted as raw bytes.  */);
 37291   unibyte_display_via_language_environment = false;
 37292 
 37293   DEFVAR_LISP ("max-mini-window-height", Vmax_mini_window_height,
 37294     doc: /* Maximum height for resizing mini-windows (the minibuffer and the echo area).
 37295 If a float, it specifies the maximum height in units of the
 37296 mini-window frame's height.
 37297 If an integer, it specifies the maximum height in units of the
 37298 mini-window frame's default font's height.  */);
 37299   Vmax_mini_window_height = make_float (0.25);
 37300 
 37301   DEFVAR_LISP ("resize-mini-windows", Vresize_mini_windows,
 37302     doc: /* How to resize mini-windows (the minibuffer and the echo area).
 37303 A value of nil means don't automatically resize mini-windows.
 37304 A value of t means resize them to fit the text displayed in them.
 37305 A value of `grow-only', the default, means let mini-windows grow only;
 37306 they return to their normal size when the minibuffer is closed, or the
 37307 echo area becomes empty.
 37308 
 37309 This variable does not affect resizing of the minibuffer window of
 37310 minibuffer-only frames.  These are handled by `resize-mini-frames'
 37311 only.  */);
 37312   /* Contrary to the doc string, we initialize this to nil, so that
 37313      loading loadup.el won't try to resize windows before loading
 37314      window.el, where some functions we need to call for this live.
 37315      We assign the 'grow-only' value right after loading window.el
 37316      during loadup.  */
 37317   Vresize_mini_windows = Qnil;
 37318 
 37319   DEFVAR_LISP ("blink-cursor-alist", Vblink_cursor_alist,
 37320     doc: /* Alist specifying how to blink the cursor off.
 37321 Each element has the form (ON-STATE . OFF-STATE).  Whenever the
 37322 `cursor-type' frame-parameter or variable equals ON-STATE,
 37323 comparing using `equal', Emacs uses OFF-STATE to specify
 37324 how to blink it off.  ON-STATE and OFF-STATE are values for
 37325 the `cursor-type' frame parameter.
 37326 
 37327 If a frame's ON-STATE has no entry in this list,
 37328 the frame's other specifications determine how to blink the cursor off.  */);
 37329   Vblink_cursor_alist = Qnil;
 37330 
 37331   DEFVAR_LISP ("auto-hscroll-mode", automatic_hscrolling,
 37332     doc: /* Allow or disallow automatic horizontal scrolling of windows.
 37333 The value `current-line' means the line displaying point in each window
 37334 is automatically scrolled horizontally to make point visible.
 37335 Any other non-nil value means all the lines in a window are automatically
 37336 scrolled horizontally to make point visible.  */);
 37337   automatic_hscrolling = Qt;
 37338   DEFSYM (Qauto_hscroll_mode, "auto-hscroll-mode");
 37339   DEFSYM (Qcurrent_line, "current-line");
 37340 
 37341   DEFVAR_INT ("hscroll-margin", hscroll_margin,
 37342     doc: /* How many columns away from the window edge point is allowed to get
 37343 before automatic hscrolling will horizontally scroll the window.  */);
 37344   hscroll_margin = 5;
 37345 
 37346   DEFVAR_LISP ("hscroll-step", Vhscroll_step,
 37347     doc: /* How many columns to scroll the window when point gets too close to the edge.
 37348 When point is less than `hscroll-margin' columns from the window
 37349 edge, automatic hscrolling will scroll the window by the amount of columns
 37350 determined by this variable.  If its value is a positive integer, scroll that
 37351 many columns.  If it's a positive floating-point number, it specifies the
 37352 fraction of the window's width to scroll.  If it's nil or zero, point will be
 37353 centered horizontally after the scroll.  Any other value, including negative
 37354 numbers, are treated as if the value were zero.
 37355 
 37356 Automatic hscrolling always moves point outside the scroll margin, so if
 37357 point was more than scroll step columns inside the margin, the window will
 37358 scroll more than the value given by the scroll step.
 37359 
 37360 Note that the lower bound for automatic hscrolling specified by `scroll-left'
 37361 and `scroll-right' overrides this variable's effect.  */);
 37362   Vhscroll_step = make_fixnum (0);
 37363 
 37364   DEFVAR_BOOL ("message-truncate-lines", message_truncate_lines,
 37365     doc: /* If non-nil, messages are truncated when displaying the echo area.
 37366 Bind this around calls to `message' to let it take effect.  */);
 37367   message_truncate_lines = false;
 37368 
 37369   DEFVAR_LISP ("menu-bar-update-hook",  Vmenu_bar_update_hook,
 37370     doc: /* Normal hook run to update the menu bar definitions.
 37371 Redisplay runs this hook before it redisplays the menu bar.
 37372 This is used to update menus such as Buffers, whose contents depend on
 37373 various data.  */);
 37374   Vmenu_bar_update_hook = Qnil;
 37375 
 37376   DEFVAR_LISP ("menu-updating-frame", Vmenu_updating_frame,
 37377                doc: /* Frame for which we are updating a menu.
 37378 The enable predicate for a menu binding should check this variable.  */);
 37379   Vmenu_updating_frame = Qnil;
 37380 
 37381   DEFVAR_BOOL ("inhibit-menubar-update", inhibit_menubar_update,
 37382     doc: /* Non-nil means don't update menu bars.  Internal use only.  */);
 37383   inhibit_menubar_update = false;
 37384 
 37385   DEFVAR_LISP ("wrap-prefix", Vwrap_prefix,
 37386     doc: /* Prefix prepended to all continuation lines at display time.
 37387 The value may be a string, an image, or a stretch-glyph; it is
 37388 interpreted in the same way as the value of a `display' text property.
 37389 
 37390 This variable is overridden by any `wrap-prefix' text or overlay
 37391 property.
 37392 
 37393 To add a prefix to non-continuation lines, use `line-prefix'.  */);
 37394   Vwrap_prefix = Qnil;
 37395   DEFSYM (Qwrap_prefix, "wrap-prefix");
 37396   Fmake_variable_buffer_local (Qwrap_prefix);
 37397 
 37398   DEFVAR_LISP ("line-prefix", Vline_prefix,
 37399     doc: /* Prefix prepended to all non-continuation lines at display time.
 37400 The value may be a string, an image, or a stretch-glyph; it is
 37401 interpreted in the same way as the value of a `display' text property.
 37402 
 37403 This variable is overridden by any `line-prefix' text or overlay
 37404 property.
 37405 
 37406 To add a prefix to continuation lines, use `wrap-prefix'.  */);
 37407   Vline_prefix = Qnil;
 37408   DEFSYM (Qline_prefix, "line-prefix");
 37409   Fmake_variable_buffer_local (Qline_prefix);
 37410 
 37411   DEFVAR_LISP ("display-line-numbers", Vdisplay_line_numbers,
 37412     doc: /* Non-nil means display line numbers.
 37413 
 37414 If the value is t, display the absolute number of each line of a buffer
 37415 shown in a window.  Absolute line numbers count from the beginning of
 37416 the current narrowing, or from buffer beginning.  The variable
 37417 `display-line-numbers-offset', if non-zero, is a signed offset added
 37418 to each absolute line number; it also forces line numbers to be counted
 37419 from the beginning of the buffer, as if `display-line-numbers-widen'
 37420 were non-nil.  It has no effect when line numbers are not absolute.
 37421 
 37422 If the value is `relative', display for each line not containing the
 37423 window's point its relative number instead, i.e. the number of the line
 37424 relative to the line showing the window's point.
 37425 
 37426 In either case, line numbers are displayed at the beginning of each
 37427 non-continuation line that displays buffer text, i.e. after each newline
 37428 character that comes from the buffer.  The value `visual' is like
 37429 `relative' but counts screen lines instead of buffer lines.  In practice
 37430 this means that continuation lines count as well when calculating the
 37431 relative number of a line.
 37432 
 37433 Lisp programs can disable display of a line number of a particular
 37434 buffer line by putting the `display-line-numbers-disable' text property
 37435 or overlay property on the first visible character of that line.  */);
 37436   Vdisplay_line_numbers = Qnil;
 37437   DEFSYM (Qdisplay_line_numbers, "display-line-numbers");
 37438   Fmake_variable_buffer_local (Qdisplay_line_numbers);
 37439   DEFSYM (Qrelative, "relative");
 37440   DEFSYM (Qvisual, "visual");
 37441 
 37442   DEFVAR_LISP ("display-line-numbers-width", Vdisplay_line_numbers_width,
 37443     doc: /* Minimum width of space reserved for line number display.
 37444 A positive number means reserve that many columns for line numbers,
 37445 even if the actual number needs less space.
 37446 The default value of nil means compute the space dynamically.
 37447 Any other value is treated as nil.  */);
 37448   Vdisplay_line_numbers_width = Qnil;
 37449   DEFSYM (Qdisplay_line_numbers_width, "display-line-numbers-width");
 37450   Fmake_variable_buffer_local (Qdisplay_line_numbers_width);
 37451 
 37452   DEFVAR_LISP ("display-line-numbers-current-absolute",
 37453                Vdisplay_line_numbers_current_absolute,
 37454     doc: /* Non-nil means display absolute number of current line.
 37455 This variable has effect only when `display-line-numbers' is
 37456 either `relative' or `visual'.  */);
 37457   Vdisplay_line_numbers_current_absolute = Qt;
 37458 
 37459   DEFVAR_BOOL ("display-line-numbers-widen", display_line_numbers_widen,
 37460     doc: /* Non-nil means display line numbers disregarding any narrowing.  */);
 37461   display_line_numbers_widen = false;
 37462   DEFSYM (Qdisplay_line_numbers_widen, "display-line-numbers-widen");
 37463   Fmake_variable_buffer_local (Qdisplay_line_numbers_widen);
 37464 
 37465   DEFVAR_INT ("display-line-numbers-offset", display_line_numbers_offset,
 37466     doc: /* A signed integer added to each absolute line number.
 37467 When this variable is non-zero, line numbers are always counted from
 37468 the beginning of the buffer even if `display-line-numbers-widen' is nil.
 37469 It has no effect when set to 0, or when line numbers are not absolute.  */);
 37470   display_line_numbers_offset = 0;
 37471   DEFSYM (Qdisplay_line_numbers_offset, "display-line-numbers-offset");
 37472   Fmake_variable_buffer_local (Qdisplay_line_numbers_offset);
 37473 
 37474   DEFVAR_BOOL ("display-fill-column-indicator", display_fill_column_indicator,
 37475     doc: /* Non-nil means display the fill column indicator.
 37476 If you set this non-nil, make sure `display-fill-column-indicator-character'
 37477 is also non-nil.
 37478 See Info node `Displaying Boundaries' for details.  */);
 37479   display_fill_column_indicator = false;
 37480   DEFSYM (Qdisplay_fill_column_indicator, "display-fill-column-indicator");
 37481   Fmake_variable_buffer_local (Qdisplay_fill_column_indicator);
 37482 
 37483   DEFVAR_LISP ("display-fill-column-indicator-column", Vdisplay_fill_column_indicator_column,
 37484     doc: /* Column for indicator when `display-fill-column-indicator' is non-nil.
 37485 The default value is t which means that the indicator
 37486 will use the `fill-column' variable.  If it is set to an integer the
 37487 indicator will be drawn in that column.
 37488 See Info node `Displaying Boundaries' for details.  */);
 37489   Vdisplay_fill_column_indicator_column = Qt;
 37490   DEFSYM (Qdisplay_fill_column_indicator_column, "display-fill-column-indicator-column");
 37491   Fmake_variable_buffer_local (Qdisplay_fill_column_indicator_column);
 37492 
 37493   DEFVAR_LISP ("display-fill-column-indicator-character", Vdisplay_fill_column_indicator_character,
 37494     doc: /* Character to draw the indicator when `display-fill-column-indicator' is non-nil.
 37495 A good candidate is U+2502, and an alternative is (ascii 124) if the
 37496 font of `fill-column-indicator' face does not support Unicode characters.
 37497 See Info node `Displaying Boundaries' for details.  */);
 37498   Vdisplay_fill_column_indicator_character = Qnil;
 37499   DEFSYM (Qdisplay_fill_column_indicator_character, "display-fill-column-indicator-character");
 37500   Fmake_variable_buffer_local (Qdisplay_fill_column_indicator_character);
 37501 
 37502   DEFVAR_INT ("display-line-numbers-major-tick", display_line_numbers_major_tick,
 37503     doc: /* If an integer N > 0, highlight line number of every Nth line.
 37504 The line number is shown with the `line-number-major-tick' face.
 37505 Otherwise, no special highlighting is done every Nth line.
 37506 Note that major ticks take precedence over minor ticks.  */);
 37507   display_line_numbers_major_tick = 0;
 37508 
 37509   DEFVAR_INT ("display-line-numbers-minor-tick", display_line_numbers_minor_tick,
 37510     doc: /* If an integer N > 0, highlight line number of every Nth line.
 37511 The line number is shown with the `line-number-minor-tick' face.
 37512 Otherwise, no special highlighting is done every Nth line.
 37513 Note that major ticks take precedence over minor ticks.  */);
 37514   display_line_numbers_minor_tick = 0;
 37515 
 37516   DEFVAR_BOOL ("inhibit-eval-during-redisplay", inhibit_eval_during_redisplay,
 37517     doc: /* Non-nil means don't eval Lisp during redisplay.  */);
 37518   inhibit_eval_during_redisplay = false;
 37519 
 37520   DEFVAR_BOOL ("inhibit-free-realized-faces", inhibit_free_realized_faces,
 37521     doc: /* Non-nil means don't free realized faces.  Internal use only.  */);
 37522   inhibit_free_realized_faces = false;
 37523 
 37524   DEFVAR_BOOL ("inhibit-bidi-mirroring", inhibit_bidi_mirroring,
 37525     doc: /* Non-nil means don't mirror characters even when bidi context requires that.
 37526 Intended for use during debugging and for testing bidi display;
 37527 see biditest.el in the test suite.  */);
 37528   inhibit_bidi_mirroring = false;
 37529 
 37530   DEFVAR_BOOL ("bidi-inhibit-bpa", bidi_inhibit_bpa,
 37531     doc: /* Non-nil means inhibit the Bidirectional Parentheses Algorithm.
 37532 Disabling the BPA makes redisplay faster, but might produce incorrect
 37533 display reordering of bidirectional text with embedded parentheses and
 37534 other bracket characters whose `paired-bracket' Unicode property is
 37535 non-nil, see `get-char-code-property'.  */);
 37536   bidi_inhibit_bpa = false;
 37537 
 37538 #ifdef GLYPH_DEBUG
 37539   DEFVAR_BOOL ("inhibit-try-window-id", inhibit_try_window_id,
 37540                doc: /* Inhibit try_window_id display optimization.  */);
 37541   inhibit_try_window_id = false;
 37542 
 37543   DEFVAR_BOOL ("inhibit-try-window-reusing", inhibit_try_window_reusing,
 37544                doc: /* Inhibit try_window_reusing display optimization.  */);
 37545   inhibit_try_window_reusing = false;
 37546 
 37547   DEFVAR_BOOL ("inhibit-try-cursor-movement", inhibit_try_cursor_movement,
 37548                doc: /* Inhibit try_cursor_movement display optimization.  */);
 37549   inhibit_try_cursor_movement = false;
 37550 #endif /* GLYPH_DEBUG */
 37551 
 37552   DEFVAR_INT ("overline-margin", overline_margin,
 37553                doc: /* Space between overline and text, in pixels.
 37554 The default value is 2: the height of the overline (1 pixel) plus 1 pixel
 37555 margin to the character height.  */);
 37556   overline_margin = 2;
 37557 
 37558   DEFVAR_INT ("underline-minimum-offset",
 37559                underline_minimum_offset,
 37560      doc: /* Minimum distance between baseline and underline.
 37561 This can improve legibility of underlined text at small font sizes,
 37562 particularly when using variable `x-use-underline-position-properties'
 37563 with fonts that specify an UNDERLINE_POSITION relatively close to the
 37564 baseline.  The default value is 1.  */);
 37565   underline_minimum_offset = 1;
 37566   DEFSYM (Qunderline_minimum_offset, "underline-minimum-offset");
 37567 
 37568   DEFVAR_BOOL ("display-hourglass", display_hourglass_p,
 37569                doc: /* Non-nil means show an hourglass pointer, when Emacs is busy.
 37570 This feature only works when on a window system that can change
 37571 cursor shapes.  */);
 37572   display_hourglass_p = true;
 37573 
 37574   DEFVAR_LISP ("hourglass-delay", Vhourglass_delay,
 37575                doc: /* Seconds to wait before displaying an hourglass pointer when Emacs is busy.  */);
 37576   Vhourglass_delay = make_fixnum (DEFAULT_HOURGLASS_DELAY);
 37577 
 37578 #ifdef HAVE_WINDOW_SYSTEM
 37579   hourglass_atimer = NULL;
 37580   hourglass_shown_p = false;
 37581 #endif /* HAVE_WINDOW_SYSTEM */
 37582 
 37583   /* Name of the face used to display glyphless characters.  */
 37584   DEFSYM (Qglyphless_char, "glyphless-char");
 37585 
 37586   /* Method symbols for Vglyphless_char_display.  */
 37587   DEFSYM (Qhex_code, "hex-code");
 37588   DEFSYM (Qempty_box, "empty-box");
 37589   DEFSYM (Qthin_space, "thin-space");
 37590   DEFSYM (Qzero_width, "zero-width");
 37591 
 37592   DEFVAR_LISP ("pre-redisplay-function", Vpre_redisplay_function,
 37593                doc: /* Function run just before redisplay.
 37594 It is called with one argument, which is the set of windows that are to
 37595 be redisplayed.  This set can be nil (meaning, only the selected window),
 37596 or t (meaning all windows).  */);
 37597   Vpre_redisplay_function = intern ("ignore");
 37598 
 37599   /* Symbol for the purpose of Vglyphless_char_display.  */
 37600   DEFSYM (Qglyphless_char_display, "glyphless-char-display");
 37601   Fput (Qglyphless_char_display, Qchar_table_extra_slots, make_fixnum (1));
 37602 
 37603   DEFVAR_LISP ("glyphless-char-display", Vglyphless_char_display,
 37604                doc: /* Char-table defining glyphless characters.
 37605 Each element, if non-nil, should be one of the following:
 37606   an ASCII acronym string: display this string in a box
 37607   `hex-code':   display the hexadecimal code of a character in a box
 37608   `empty-box':  display as an empty box
 37609   `thin-space': display as 1-pixel width space
 37610   `zero-width': don't display
 37611 Any other value is interpreted as `empty-box'.
 37612 An element may also be a cons cell (GRAPHICAL . TEXT), which specifies the
 37613 display method for graphical terminals and text terminals respectively.
 37614 GRAPHICAL and TEXT should each have one of the values listed above.
 37615 
 37616 The char-table has one extra slot to control the display of characters
 37617 for which no font is found on graphical terminals, and characters that
 37618 cannot be displayed by text-mode terminals.  Its value should be an
 37619 ASCII acronym string, `hex-code', `empty-box', or `thin-space'.  It
 37620 could also be a cons cell of any two of these, to specify separate
 37621 values for graphical and text terminals.  The default is `empty-box'.
 37622 
 37623 With the obvious exception of `zero-width', all the other representations
 37624 are displayed using the face `glyphless-char'.
 37625 
 37626 If a character has a non-nil entry in an active display table, the
 37627 display table takes effect; in this case, Emacs does not consult
 37628 `glyphless-char-display' at all.  */);
 37629   Vglyphless_char_display = Fmake_char_table (Qglyphless_char_display, Qnil);
 37630   Fset_char_table_extra_slot (Vglyphless_char_display, make_fixnum (0),
 37631                               Qempty_box);
 37632 
 37633   DEFVAR_LISP ("debug-on-message", Vdebug_on_message,
 37634                doc: /* If non-nil, debug if a message matching this regexp is displayed.  */);
 37635   Vdebug_on_message = Qnil;
 37636 
 37637   DEFVAR_LISP ("set-message-function", Vset_message_function,
 37638                doc: /* If non-nil, function to handle display of echo-area messages.
 37639 The function is called with one argument that is the text of a message.
 37640 If this function returns nil, the message is displayed in the echo area
 37641 as usual.  If the function returns a string, the returned string is
 37642 displayed in the echo area.  If this function returns any other non-nil
 37643 value, this means that the message was already handled, and the original
 37644 message text will not be displayed in the echo area.
 37645 
 37646 Also see `clear-message-function' (which can be used to clear the
 37647 message displayed by this function), and `command-error-function'
 37648 (which controls how error messages are displayed).  */);
 37649   Vset_message_function = Qnil;
 37650 
 37651   DEFSYM (Qdont_clear_message, "dont-clear-message");
 37652   DEFVAR_LISP ("clear-message-function", Vclear_message_function,
 37653                doc: /* If non-nil, function to clear echo-area messages.
 37654 Usually this function is called when the next input event arrives.
 37655 It is expected to clear the message displayed by its counterpart
 37656 function specified by `set-message-function'.
 37657 
 37658 The function is called without arguments.
 37659 
 37660 If this function returns a value that isn't `dont-clear-message', the
 37661 message is cleared from the echo area as usual.  If this function
 37662 returns `dont-clear-message', this means that the message was already
 37663 handled, and the original message text will not be cleared from the
 37664 echo area.  */);
 37665   Vclear_message_function = Qnil;
 37666 
 37667   DEFVAR_LISP ("redisplay--all-windows-cause", Vredisplay__all_windows_cause,
 37668                doc: /* Code of the cause for redisplaying all windows.
 37669 Internal use only.  */);
 37670   Vredisplay__all_windows_cause = Fmake_hash_table (0, NULL);
 37671 
 37672   DEFVAR_LISP ("redisplay--mode-lines-cause", Vredisplay__mode_lines_cause,
 37673                doc: /* Code of the cause for redisplaying mode lines.
 37674 Internal use only.  */);
 37675   Vredisplay__mode_lines_cause = Fmake_hash_table (0, NULL);
 37676 
 37677   DEFVAR_BOOL ("redisplay--inhibit-bidi", redisplay__inhibit_bidi,
 37678      doc: /* Non-nil means it is not safe to attempt bidi reordering for display.  */);
 37679   /* Initialize to t, since we need to disable reordering until
 37680      loadup.el successfully loads charprop.el.  */
 37681   redisplay__inhibit_bidi = true;
 37682 
 37683   DEFVAR_BOOL ("display-raw-bytes-as-hex", display_raw_bytes_as_hex,
 37684     doc: /* Non-nil means display raw bytes in hexadecimal format.
 37685 The default is to use octal format (\\200) whereas hexadecimal (\\x80)
 37686 may be more familiar to users.  */);
 37687   display_raw_bytes_as_hex = false;
 37688 
 37689   DEFVAR_BOOL ("mouse-fine-grained-tracking", mouse_fine_grained_tracking,
 37690     doc: /* Non-nil for pixel-wise mouse-movement.
 37691 When nil, mouse-movement events will not be generated as long as the
 37692 mouse stays within the extent of a single glyph (except for images).  */);
 37693   mouse_fine_grained_tracking = false;
 37694 
 37695   DEFVAR_BOOL ("tab-bar--dragging-in-progress", tab_bar__dragging_in_progress,
 37696     doc: /* Non-nil when maybe dragging tab bar item.  */);
 37697   tab_bar__dragging_in_progress = false;
 37698 
 37699   DEFVAR_BOOL ("redisplay-skip-initial-frame", redisplay_skip_initial_frame,
 37700     doc: /* Non-nil means skip redisplay of the initial frame.
 37701 The initial frame is the text-mode frame used by Emacs internally during
 37702 the early stages of startup.  That frame is not displayed anywhere, so
 37703 skipping it is best except in special circumstances such as running
 37704 redisplay tests in batch mode.   */);
 37705   redisplay_skip_initial_frame = true;
 37706 
 37707   DEFVAR_BOOL ("redisplay-skip-fontification-on-input",
 37708                redisplay_skip_fontification_on_input,
 37709     doc: /* Skip `fontification_functions` when there is input pending.
 37710 If non-nil and there was input pending at the beginning of the command,
 37711 the `fontification_functions` hook is not run.  This usually does not
 37712 affect the display because redisplay is completely skipped anyway if input
 37713 was pending, but it can make scrolling smoother by avoiding
 37714 unnecessary fontification.
 37715 It is similar to `fast-but-imprecise-scrolling' with similar tradeoffs,
 37716 but with the advantage that it should only affect the behavior when Emacs
 37717 has trouble keeping up with the incoming input rate.  */);
 37718   redisplay_skip_fontification_on_input = false;
 37719 
 37720   DEFVAR_BOOL ("redisplay-adhoc-scroll-in-resize-mini-windows",
 37721                redisplay_adhoc_scroll_in_resize_mini_windows,
 37722     doc: /* If nil always use normal scrolling in minibuffer windows.
 37723 Otherwise, use custom-tailored code after resizing minibuffer windows to try
 37724 and display the most important part of the minibuffer.   */);
 37725   /* See bug#43519 for some discussion around this.  */
 37726   redisplay_adhoc_scroll_in_resize_mini_windows = true;
 37727 
 37728   DEFVAR_BOOL ("composition-break-at-point", composition_break_at_point,
 37729     doc: /* If non-nil, prevent auto-composition of characters around point.
 37730 This makes it easier to edit character sequences that are
 37731 composed on display.  */);
 37732   composition_break_at_point = false;
 37733 
 37734   DEFVAR_INT ("max-redisplay-ticks", max_redisplay_ticks,
 37735     doc: /* Maximum number of redisplay ticks before aborting redisplay of a window.
 37736 
 37737 This allows to abort the display of a window if the amount of low-level
 37738 redisplay operations exceeds the value of this variable.  When display of
 37739 a window is aborted due to this reason, the buffer shown in that window
 37740 will not have its windows redisplayed until the buffer is modified or until
 37741 you type \\[recenter-top-bottom] with one of its windows selected.
 37742 You can also decide to kill the buffer and visit it in some
 37743 other way, like under `so-long-mode' or literally.
 37744 
 37745 The default value is zero, which disables this feature.
 37746 The recommended non-zero value is between 100000 and 1000000,
 37747 depending on your patience and the speed of your system.  */);
 37748   max_redisplay_ticks = 0;
 37749 }
 37750 
 37751 
 37752 /* Initialize this module when Emacs starts.  */
 37753 
 37754 void
 37755 init_xdisp (void)
 37756 {
 37757   CHARPOS (this_line_start_pos) = 0;
 37758 
 37759   echo_area_window = minibuf_window;
 37760 
 37761   if (!noninteractive)
 37762     {
 37763       struct window *m = XWINDOW (minibuf_window);
 37764       Lisp_Object frame = m->frame;
 37765       struct frame *f = XFRAME (frame);
 37766       Lisp_Object root = FRAME_ROOT_WINDOW (f);
 37767       struct window *r = XWINDOW (root);
 37768       int i;
 37769 
 37770       r->top_line = FRAME_TOP_MARGIN (f);
 37771       r->pixel_top = r->top_line * FRAME_LINE_HEIGHT (f);
 37772       r->total_cols = FRAME_COLS (f);
 37773       r->pixel_width = r->total_cols * FRAME_COLUMN_WIDTH (f);
 37774       r->total_lines = FRAME_TOTAL_LINES (f) - 1 - FRAME_MARGINS (f);
 37775       r->pixel_height = r->total_lines * FRAME_LINE_HEIGHT (f);
 37776 
 37777       m->top_line = FRAME_TOTAL_LINES (f) - 1;
 37778       m->pixel_top = m->top_line * FRAME_LINE_HEIGHT (f);
 37779       m->total_cols = FRAME_COLS (f);
 37780       m->pixel_width = m->total_cols * FRAME_COLUMN_WIDTH (f);
 37781       m->total_lines = 1;
 37782       m->pixel_height = m->total_lines * FRAME_LINE_HEIGHT (f);
 37783 
 37784       scratch_glyph_row.glyphs[TEXT_AREA] = scratch_glyphs;
 37785       scratch_glyph_row.glyphs[TEXT_AREA + 1]
 37786         = scratch_glyphs + MAX_SCRATCH_GLYPHS;
 37787 
 37788       /* The default ellipsis glyphs `...'.  */
 37789       for (i = 0; i < 3; ++i)
 37790         default_invis_vector[i] = make_fixnum ('.');
 37791     }
 37792 
 37793   {
 37794     /* Allocate the buffer for frame titles.
 37795        Also used for `format-mode-line'.  */
 37796     int size = 100;
 37797     mode_line_noprop_buf = xmalloc (size);
 37798     mode_line_noprop_buf_end = mode_line_noprop_buf + size;
 37799     mode_line_noprop_ptr = mode_line_noprop_buf;
 37800     mode_line_target = MODE_LINE_DISPLAY;
 37801   }
 37802 
 37803   help_echo_showing_p = false;
 37804 }
 37805 
 37806 #ifdef HAVE_WINDOW_SYSTEM
 37807 
 37808 /* Platform-independent portion of hourglass implementation.  */
 37809 
 37810 /* Timer function of hourglass_atimer.  */
 37811 
 37812 static void
 37813 show_hourglass (struct atimer *timer)
 37814 {
 37815   /* The timer implementation will cancel this timer automatically
 37816      after this function has run.  Set hourglass_atimer to null
 37817      so that we know the timer doesn't have to be canceled.  */
 37818   hourglass_atimer = NULL;
 37819 
 37820   if (!hourglass_shown_p)
 37821     {
 37822       Lisp_Object tail, frame;
 37823 
 37824       block_input ();
 37825 
 37826       FOR_EACH_FRAME (tail, frame)
 37827         {
 37828           struct frame *f = XFRAME (frame);
 37829 
 37830           if (FRAME_LIVE_P (f) && FRAME_WINDOW_P (f)
 37831               && FRAME_RIF (f)->show_hourglass)
 37832             FRAME_RIF (f)->show_hourglass (f);
 37833         }
 37834 
 37835       hourglass_shown_p = true;
 37836       unblock_input ();
 37837     }
 37838 }
 37839 
 37840 /* Cancel a currently active hourglass timer, and start a new one.  */
 37841 
 37842 void
 37843 start_hourglass (void)
 37844 {
 37845   struct timespec delay;
 37846 
 37847   cancel_hourglass ();
 37848 
 37849   if (FIXNUMP (Vhourglass_delay)
 37850       && XFIXNUM (Vhourglass_delay) > 0)
 37851     delay = make_timespec (min (XFIXNUM (Vhourglass_delay),
 37852                                   TYPE_MAXIMUM (time_t)),
 37853                            0);
 37854   else if (FLOATP (Vhourglass_delay)
 37855            && XFLOAT_DATA (Vhourglass_delay) > 0)
 37856     delay = dtotimespec (XFLOAT_DATA (Vhourglass_delay));
 37857   else
 37858     delay = make_timespec (DEFAULT_HOURGLASS_DELAY, 0);
 37859 
 37860   hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,
 37861                                    show_hourglass, NULL);
 37862 }
 37863 
 37864 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
 37865    shown.  */
 37866 
 37867 void
 37868 cancel_hourglass (void)
 37869 {
 37870   if (hourglass_atimer)
 37871     {
 37872       cancel_atimer (hourglass_atimer);
 37873       hourglass_atimer = NULL;
 37874     }
 37875 
 37876   if (hourglass_shown_p)
 37877     {
 37878       Lisp_Object tail, frame;
 37879 
 37880       block_input ();
 37881 
 37882       FOR_EACH_FRAME (tail, frame)
 37883         {
 37884           struct frame *f = XFRAME (frame);
 37885 
 37886           if (FRAME_LIVE_P (f) && FRAME_WINDOW_P (f)
 37887               && FRAME_RIF (f)->hide_hourglass)
 37888             FRAME_RIF (f)->hide_hourglass (f);
 37889 #ifdef HAVE_NTGUI
 37890           /* No cursors on non GUI frames - restore to stock arrow cursor.  */
 37891           else if (!FRAME_W32_P (f))
 37892             w32_arrow_cursor ();
 37893 #endif
 37894         }
 37895 
 37896       hourglass_shown_p = false;
 37897       unblock_input ();
 37898     }
 37899 }
 37900 
 37901 /* Return a correction to be applied to G->pixel_width when it is
 37902    displayed in MOUSE_FACE.  This is needed for the first and the last
 37903    glyphs of text inside a face with :box when it is displayed with
 37904    MOUSE_FACE that has a different or no :box attribute.
 37905    ORIGINAL_FACE is the face G was originally drawn in, and MOUSE_FACE
 37906    is the face it will be drawn in now.  ROW is the G's glyph row and
 37907    W is its window.  */
 37908 static int
 37909 adjust_glyph_width_for_mouse_face (struct glyph *g, struct glyph_row *row,
 37910                                    struct window *w,
 37911                                    struct face *original_face,
 37912                                    struct face *mouse_face)
 37913 {
 37914   int sum = 0;
 37915 
 37916   bool do_left_box_p = g->left_box_line_p;
 37917   bool do_right_box_p = g->right_box_line_p;
 37918 
 37919   /* This is required because we test some parameters of the image
 37920      slice before applying the box in produce_image_glyph.  */
 37921   if (g->type == IMAGE_GLYPH)
 37922     {
 37923       if (!row->reversed_p)
 37924         {
 37925           struct image *img = IMAGE_FROM_ID (WINDOW_XFRAME (w),
 37926                                              g->u.img_id);
 37927           do_left_box_p = g->left_box_line_p &&
 37928             g->slice.img.x == 0;
 37929           do_right_box_p = g->right_box_line_p &&
 37930             g->slice.img.x + g->slice.img.width == img->width;
 37931         }
 37932       else
 37933         {
 37934           struct image *img = IMAGE_FROM_ID (WINDOW_XFRAME (w),
 37935                                              g->u.img_id);
 37936           do_left_box_p = g->left_box_line_p &&
 37937             g->slice.img.x + g->slice.img.width == img->width;
 37938           do_right_box_p = g->right_box_line_p &&
 37939             g->slice.img.x == 0;
 37940         }
 37941     }
 37942 
 37943   /* If the glyph has a left box line, subtract it from the offset.  */
 37944   if (do_left_box_p)
 37945     sum -= max (0, original_face->box_vertical_line_width);
 37946   /* Likewise with the right box line, as there may be a
 37947      box there as well.  */
 37948   if (do_right_box_p)
 37949     sum -= max (0, original_face->box_vertical_line_width);
 37950   /* Now add the line widths from the new face.  */
 37951   if (g->left_box_line_p)
 37952     sum += max (0, mouse_face->box_vertical_line_width);
 37953   if (g->right_box_line_p)
 37954     sum += max (0, mouse_face->box_vertical_line_width);
 37955 
 37956   return sum;
 37957 }
 37958 
 37959 /* Get the offset due to mouse-highlight to apply before drawing
 37960    phys_cursor, and return it in OFFSET.  ROW should be the row that
 37961    is under mouse face and contains the phys cursor.
 37962 
 37963    This is required because the produce_XXX_glyph series of functions
 37964    add the width of the various vertical box lines to the total width
 37965    of the glyphs, but that must be updated when the row is put under
 37966    mouse face, which can have different box dimensions.  */
 37967 static void
 37968 get_cursor_offset_for_mouse_face (struct window *w, struct glyph_row *row,
 37969                                   int *offset)
 37970 {
 37971   int sum = 0;
 37972   /* Return because the mode line can't possibly have a cursor. */
 37973   if (row->mode_line_p)
 37974     return;
 37975 
 37976   block_input ();
 37977 
 37978   struct frame *f = WINDOW_XFRAME (w);
 37979   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 37980   struct glyph *start, *end;
 37981   struct face *mouse_face = FACE_FROM_ID (f, hlinfo->mouse_face_face_id);
 37982   int hpos = w->phys_cursor.hpos;
 37983   end = &row->glyphs[TEXT_AREA][hpos];
 37984 
 37985   if (!row->reversed_p)
 37986     {
 37987       if (MATRIX_ROW_VPOS (row, w->current_matrix) ==
 37988           hlinfo->mouse_face_beg_row)
 37989         start = &row->glyphs[TEXT_AREA][hlinfo->mouse_face_beg_col];
 37990       else
 37991         start = row->glyphs[TEXT_AREA];
 37992     }
 37993   else
 37994     {
 37995       if (MATRIX_ROW_VPOS (row, w->current_matrix) ==
 37996           hlinfo->mouse_face_end_row)
 37997         start = &row->glyphs[TEXT_AREA][hlinfo->mouse_face_end_col];
 37998       else
 37999         start = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
 38000     }
 38001 
 38002   /* Calculate the offset by which to correct phys_cursor x if we are
 38003      drawing the cursor inside mouse-face highlighted text.  */
 38004 
 38005   for ( ; row->reversed_p ? start > end : start < end;
 38006           row->reversed_p ? --start : ++start)
 38007     sum += adjust_glyph_width_for_mouse_face (start, row, w,
 38008                                               FACE_FROM_ID (f, start->face_id),
 38009                                               mouse_face);
 38010 
 38011   if (row->reversed_p)
 38012     sum = -sum;
 38013 
 38014   *offset = sum;
 38015 
 38016   unblock_input ();
 38017 }
 38018 #endif /* HAVE_WINDOW_SYSTEM */